import Mathlib.Algebra.Group.Defs
import Mathlib.Init.Algebra.Order
import ECTate.Algebra.Ring.Basic
import Mathlib.Init.Data.Nat.Lemmas
import ECTate.Init.Data.Int.Lemmas
import ECTate.Data.Nat.Enat
import ECTate.Algebra.EllipticCurve.Kronecker
import Mathlib.Tactic.LibrarySearch
import Mathlib.Tactic.Ring
import Mathlib.Tactic.Convert
--class ValueMonoid (A : Type u) extends AddCommMonoid A, LinearOrder A

open Enat

section Obvious

lemma match_non_zero: ∀ {β : Sort u_1} (x : ℕ∪∞) {c1 c2 : β},
  x ≠ 0 →
    (match x with
      | ofN Nat.zero => c1
      | x => c2) =       c2
match_non_zero (x: ℕ∪∞
x : ℕ∪∞: Type
ℕ∪∞) {c1: β
c1 c2: β
c2 : β: ?m.5
β} : x: ℕ∪∞
x ≠ 0: ?m.18
0 → (match x: ℕ∪∞
x with | 0: ℕ∪∞
0 => c1: β
c1 | _ => c2: β
c2) = c2: β
c2 := by
  β: Sort u_1

x: ℕ∪∞

c1, c2: β

x ≠ 0 →
  (match x with
    | ofN Nat.zero => c1
    | x => c2) =     c2intro h: x ≠ 0
hβ: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2
  β: Sort u_1

x: ℕ∪∞

c1, c2: β

x ≠ 0 →
  (match x with
    | ofN Nat.zero => c1
    | x => c2) =     c2match x: ℕ∪∞
x with
  β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2| ofN: ℕ → ℕ∪∞
ofN 0: ℕ
0 =>β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: ofN 0 ≠ 0

(match ofN 0 with
  | ofN Nat.zero => c1
  | x => c2) =   c2 β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2exact False.elim: ∀ {C : Sort ?u.636}, False → C
False.elim (h: ofN 0 ≠ 0
h (Eq.refl: ∀ {α : Sort ?u.638} (a : α), a = a
Eq.refl 0: ?m.641
0))
Goals accomplished! 🐙
  β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2| ∞ =>β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: ∞ ≠ 0

(match ∞ with
  | ofN Nat.zero => c1
  | x => c2) =   c2 β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2simp
Goals accomplished! 🐙
  β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2| ofN: ℕ → ℕ∪∞
ofN (β: Sort u_1

x: ℕ∪∞

c1, c2: β

n: ℕ

h: ofN (n + 1) ≠ 0

(match ofN (n + 1) with
  | ofN Nat.zero => c1
  | x => c2) =   c2n: ℕ
nWarning: unused variable `n` [linter.unusedVariables]
β: Sort u_1

x: ℕ∪∞

c1, c2: β

n: ℕ

h: ofN (n + 1) ≠ 0

(match ofN (n + 1) with
  | ofN Nat.zero => c1
  | x => c2) =   c2+1) =>β: Sort u_1

x: ℕ∪∞

c1, c2: β

n: ℕ

h: ofN (n + 1) ≠ 0

(match ofN (n + 1) with
  | ofN Nat.zero => c1
  | x => c2) =   c2 β: Sort u_1

x: ℕ∪∞

c1, c2: β

h: x ≠ 0

(match x with
  | ofN Nat.zero => c1
  | x => c2) =   c2simp
Goals accomplished! 🐙

theorem nat_mul_left_cancel: ∀ (a b c : ℕ), a ≠ 0 → a * b = a * c → b = c
nat_mul_left_cancel (a: ℕ
a b: ℕ
b c: ℕ
c : Nat: Type
Nat) (h: a ≠ 0
h : a: ℕ
a ≠ 0: ?m.940
0) : a: ℕ
a * b: ℕ
b = a: ℕ
a * c: ℕ
c → b: ℕ
b = c: ℕ
c :=
Nat.eq_of_mul_eq_mul_left: ∀ {m k n : ℕ}, 0 < n → n * m = n * k → m = k
Nat.eq_of_mul_eq_mul_left (Nat.pos_of_ne_zero: ∀ {n : ℕ}, n ≠ 0 → 0 < n
Nat.pos_of_ne_zero h: a ≠ 0
h)

end Obvious

structure SurjVal: {R : Type u} →
  {p : R} →
    [inst : IntegralDomain R] →
      (v : R → ℕ∪∞) →
        v p = ofN 1 →
          (∀ (a b : R), v (a * b) = v a + v b) →
            (∀ (a b : R), v (a + b) ≥ min (v a) (v b)) → (∀ (a : R), v a = ∞ ↔ a = 0) → SurjVal p
SurjVal {R: Type u
R : Type u: Type (u + 1)
Type u} (p: R
p : R: Type u
R) [IntegralDomain: Type ?u.1068 → Type ?u.1068
IntegralDomain R: Type u
R] where
  v: {R : Type u} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v : R: Type u
R → ℕ∪∞: Type
ℕ∪∞
  v_uniformizer: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
v_uniformizer : v: R → ℕ∪∞
v p: R
p = ofN: ℕ → ℕ∪∞
ofN 1: ?m.1079
1
  v_mul_eq_add_v: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_v (a: R
a b: R
b : R: Type u
R) : v: R → ℕ∪∞
v (a: R
a * b: R
b) = v: R → ℕ∪∞
v a: R
a + v: R → ℕ∪∞
v b: R
b
  v_add_ge_min_v: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a + b) ≥ min (SurjVal.v self a) (SurjVal.v self b)
v_add_ge_min_v (a: R
a b: R
b : R: Type u
R) : v: R → ℕ∪∞
v (a: R
a + b: R
b) ≥ min: {α : Type ?u.1326} → [self : Min α] → α → α → α
min (v: R → ℕ∪∞
v a: R
a) (v: R → ℕ∪∞
v b: R
b)
  v_eq_top_iff_zero: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero (a: R
a : R: Type u
R) : v: R → ℕ∪∞
v a: R
a = ∞: ℕ∪∞
∞ ↔ a: R
a = 0: ?m.1352
0

variable {R: Type u
R : Type u: Type (u + 1)
Type u} [IntegralDomain: Type ?u.2226 → Type ?u.2226
IntegralDomain R: Type u
R]

section SurjVal

lemma p_non_zero: ∀ {R : Type u} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2061} → R → [inst : IntegralDomain R] → Type ?u.2061
SurjVal p: R
p) : ¬p: R
p = 0: ?m.2071
0 := by
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬p = 0rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬p = 0←nav: SurjVal p
nav.v_eq_top_iff_zero: ∀ {R : Type ?u.2143} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬SurjVal.v nav p = ∞ R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬p = 0nav: SurjVal p
nav.v_uniformizer: ∀ {R : Type ?u.2158} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
v_uniformizerR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬ofN 1 = ∞]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬ofN 1 = ∞
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

¬p = 0simp
Goals accomplished! 🐙

@[simp]
lemma val_zero: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (nav : SurjVal p), SurjVal.v nav 0 = ∞
val_zero {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2231} → R → [inst : IntegralDomain R] → Type ?u.2231
SurjVal p: R
p) : nav: SurjVal p
nav.v: {R : Type ?u.2240} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v 0: ?m.2248
0 = ∞: ℕ∪∞
∞ := (nav: SurjVal p
nav.v_eq_top_iff_zero: ∀ {R : Type ?u.2303} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero 0: ?m.2308
0).2: ∀ {a b : Prop}, (a ↔ b) → b → a
2 rfl: ∀ {α : Sort ?u.2314} {a : α}, a = a
rfl

lemma val_mul_ge_left: ∀ {p : R} (nav : SurjVal p) (a b : R), SurjVal.v nav (a * b) ≥ SurjVal.v nav a
val_mul_ge_left {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2340} → R → [inst : IntegralDomain R] → Type ?u.2340
SurjVal p: R
p) (a: R
a b: R
b : R: Type u
R) : nav: SurjVal p
nav.v: {R : Type ?u.2353} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a * b: R
b) ≥ nav: SurjVal p
nav.v: {R : Type ?u.2453} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a :=
Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans (le_add_right: ∀ (n k : ℕ∪∞), n ≤ n + k
le_add_right (nav: SurjVal p
nav.v: {R : Type ?u.2478} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a) (nav: SurjVal p
nav.v: {R : Type ?u.2482} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b)) (le_of_eq: ∀ {α : Type ?u.2486} [inst : Preorder α] {a b : α}, a = b → a ≤ b
le_of_eq (nav: SurjVal p
nav.v_mul_eq_add_v: ∀ {R : Type ?u.2493} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_v a: R
a b: R
b).symm: ∀ {α : Sort ?u.2497} {a b : α}, a = b → b = a
symm)

lemma val_mul_ge_right: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R), SurjVal.v nav (a * b) ≥ SurjVal.v nav b
val_mul_ge_right {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2522} → R → [inst : IntegralDomain R] → Type ?u.2522
SurjVal p: R
p) (a: R
a b: R
b : R: Type u
R) : nav: SurjVal p
nav.v: {R : Type ?u.2535} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a * b: R
b) ≥ nav: SurjVal p
nav.v: {R : Type ?u.2635} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b := by
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

SurjVal.v nav (a * b) ≥ SurjVal.v nav brw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

SurjVal.v nav (a * b) ≥ SurjVal.v nav bmul_comm: ∀ {G : Type ?u.2655} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_commR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

SurjVal.v nav (b * a) ≥ SurjVal.v nav b]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

SurjVal.v nav (b * a) ≥ SurjVal.v nav b
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

SurjVal.v nav (a * b) ≥ SurjVal.v nav bexact val_mul_ge_left: ∀ {R : Type ?u.2729} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R),
  SurjVal.v nav (a * b) ≥ SurjVal.v nav a
val_mul_ge_left nav: SurjVal p
nav b: R
b a: R
a
Goals accomplished! 🐙

lemma val_mul_ge_of_left_ge: ∀ {n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R}, SurjVal.v nav a ≥ n → SurjVal.v nav (a * b) ≥ n
val_mul_ge_of_left_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2786} → R → [inst : IntegralDomain R] → Type ?u.2786
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (ha: SurjVal.v nav a ≥ n
ha : nav: SurjVal p
nav.v: {R : Type ?u.2796} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a ≥ n: ?m.2781
n) : nav: SurjVal p
nav.v: {R : Type ?u.2808} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a * b: R
b) ≥ n: ?m.2781
n :=
Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans ha: SurjVal.v nav a ≥ n
ha (val_mul_ge_left: ∀ {R : Type ?u.2927} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R),
  SurjVal.v nav (a * b) ≥ SurjVal.v nav a
val_mul_ge_left nav: SurjVal p
nav a: R
a b: R
b)

lemma val_mul_ge_of_right_ge: ∀ {n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R}, SurjVal.v nav b ≥ n → SurjVal.v nav (a * b) ≥ n
val_mul_ge_of_right_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.2976} → R → [inst : IntegralDomain R] → Type ?u.2976
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (hb: SurjVal.v nav b ≥ n
hb : nav: SurjVal p
nav.v: {R : Type ?u.2986} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b ≥ n: ?m.2971
n) : nav: SurjVal p
nav.v: {R : Type ?u.2998} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a * b: R
b) ≥ n: ?m.2971
n :=
Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans hb: SurjVal.v nav b ≥ n
hb (val_mul_ge_right: ∀ {R : Type ?u.3117} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R),
  SurjVal.v nav (a * b) ≥ SurjVal.v nav b
val_mul_ge_right nav: SurjVal p
nav a: R
a b: R
b)

lemma val_mul_ge_of_both_ge: ∀ {m n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R},
  SurjVal.v nav a ≥ m → SurjVal.v nav b ≥ n → SurjVal.v nav (a * b) ≥ m + n
val_mul_ge_of_both_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.3198} → R → [inst : IntegralDomain R] → Type ?u.3198
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (ha: SurjVal.v nav a ≥ m
ha : nav: SurjVal p
nav.v: {R : Type ?u.3176} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a ≥ m: ?m.3161
m) (hb: SurjVal.v nav b ≥ n
hb : nav: SurjVal p
nav.v: {R : Type ?u.3217} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b ≥ n: ?m.3193
n) :
nav: SurjVal p
nav.v: {R : Type ?u.3226} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a * b: R
b) ≥ m: ?m.3161
m + n: ?m.3193
n := by
  R: Type u

inst✝: IntegralDomain R

m, n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ m

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a * b) ≥ m + nrw [R: Type u

inst✝: IntegralDomain R

m, n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ m

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a * b) ≥ m + nnav: SurjVal p
nav.v_mul_eq_add_v: ∀ {R : Type ?u.3384} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_vR: Type u

inst✝: IntegralDomain R

m, n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ m

hb: SurjVal.v nav b ≥ n

SurjVal.v nav a + SurjVal.v nav b ≥ m + n]R: Type u

inst✝: IntegralDomain R

m, n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ m

hb: SurjVal.v nav b ≥ n

SurjVal.v nav a + SurjVal.v nav b ≥ m + n
  R: Type u

inst✝: IntegralDomain R

m, n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ m

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a * b) ≥ m + napply add_le_add: ∀ {a b c d : ℕ∪∞}, a ≤ b → c ≤ d → a + c ≤ b + d
add_le_add ha: SurjVal.v nav a ≥ m
ha hb: SurjVal.v nav b ≥ n
hb
Goals accomplished! 🐙

@[simp]
lemma val_of_one: ∀ {p : R} (nav : SurjVal p), SurjVal.v nav 1 = ofN 0
val_of_one {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.3442} → R → [inst : IntegralDomain R] → Type ?u.3442
SurjVal p: R
p) : nav: SurjVal p
nav.v: {R : Type ?u.3451} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v 1: ?m.3459
1 = ofN: ℕ → ℕ∪∞
ofN 0: ?m.3511
0 := by
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

SurjVal.v nav 1 = ofN 0apply Enat.add_right_cancel_ofN: ∀ (a : ℕ) (b c : ℕ∪∞), b + ofN a = c + ofN a → b = c
Enat.add_right_cancel_ofN 1: ?m.3528
1R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN 0 + ofN 1
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

SurjVal.v nav 1 = ofN 0rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN 0 + ofN 1add_ofN: ∀ (a b : ℕ), ofN a + ofN b = ofN (a + b)
add_ofN,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN (0 + 1) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN 0 + ofN 1←SurjVal.v_uniformizer: ∀ {R : Type ?u.3566} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
SurjVal.v_uniformizer nav: SurjVal p
nav,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + SurjVal.v nav p = SurjVal.v nav p R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN 0 + ofN 1←SurjVal.v_mul_eq_add_v: ∀ {R : Type ?u.3576} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
SurjVal.v_mul_eq_add_v nav: SurjVal p
nav,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav (1 * p) = SurjVal.v nav p R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav 1 + ofN 1 = ofN 0 + ofN 1one_mul: ∀ {M : Type ?u.3595} [inst : MulOneClass M] (a : M), 1 * a = a
one_mulR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

aSurjVal.v nav p = SurjVal.v nav p]
Goals accomplished! 🐙

lemma val_pow_ge_of_ge: ∀ {m : ℕ∪∞} {p : R} (nav : SurjVal p) {a : R} (k : ℕ), SurjVal.v nav a ≥ m → SurjVal.v nav (a ^ k) ≥ k • m
val_pow_ge_of_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.3745} → R → [inst : IntegralDomain R] → Type ?u.3745
SurjVal p: R
p) {a: R
a : R: Type u
R} (k: ℕ
k : ℕ: Type
ℕ) (ha: SurjVal.v nav a ≥ m
ha : nav: SurjVal p
nav.v: {R : Type ?u.3755} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a ≥ m: ?m.3740
m) :
nav: SurjVal p
nav.v: {R : Type ?u.3767} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a ^ k: ℕ
k) ≥ k: ℕ
k • m: ?m.3740
m := by
  R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

k: ℕ

ha: SurjVal.v nav a ≥ m

SurjVal.v nav (a ^ k) ≥ k • minduction k: ℕ
k with
  R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

k: ℕ

ha: SurjVal.v nav a ≥ m

SurjVal.v nav (a ^ k) ≥ k • m| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

ha: SurjVal.v nav a ≥ m

zeroSurjVal.v nav (a ^ Nat.zero) ≥ Nat.zero • msimp [zero_nsmul: ∀ {M : Type ?u.4082} [inst : AddMonoid M] (a : M), 0 • a = 0
zero_nsmul]
Goals accomplished! 🐙 -- TODO why isn't this simp?
  R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

k: ℕ

ha: SurjVal.v nav a ≥ m

SurjVal.v nav (a ^ k) ≥ k • m| succ: ℕ → ℕ
succ k: ℕ
k ih: ?m.4076 k
ih =>
    R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

ha: SurjVal.v nav a ≥ m

k: ℕ

ih: SurjVal.v nav (a ^ k) ≥ k • m

succSurjVal.v nav (a ^ Nat.succ k) ≥ Nat.succ k • msimp [succ_nsmul: ∀ {M : Type ?u.6604} [inst : AddMonoid M] (a : M) (n : ℕ), (n + 1) • a = a + n • a
succ_nsmul, pow_succ: ∀ {M : Type ?u.6614} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ]R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

ha: SurjVal.v nav a ≥ m

k: ℕ

ih: SurjVal.v nav (a ^ k) ≥ k • m

succSurjVal.v nav (a * a ^ k) ≥ m + k • m
    R: Type u

inst✝: IntegralDomain R

m: ℕ∪∞

p: R

nav: SurjVal p

a: R

ha: SurjVal.v nav a ≥ m

k: ℕ

ih: SurjVal.v nav (a ^ k) ≥ k • m

succSurjVal.v nav (a ^ Nat.succ k) ≥ Nat.succ k • mapply val_mul_ge_of_both_ge: ∀ {R : Type ?u.11070} [inst : IntegralDomain R] {m n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R},
  SurjVal.v nav a ≥ m → SurjVal.v nav b ≥ n → SurjVal.v nav (a * b) ≥ m + n
val_mul_ge_of_both_ge _: SurjVal ?m.11075
_ ha: SurjVal.v nav a ≥ m
ha ih: ?m.4076 k
ih
Goals accomplished! 🐙

lemma val_add_ge_of_ge: ∀ {R : Type u} [inst : IntegralDomain R] {n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R},
  SurjVal.v nav a ≥ n → SurjVal.v nav b ≥ n → SurjVal.v nav (a + b) ≥ n
val_add_ge_of_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.11142} → R → [inst : IntegralDomain R] → Type ?u.11142
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (ha: SurjVal.v nav a ≥ n
ha : nav: SurjVal p
nav.v: {R : Type ?u.11152} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a ≥ n: ?m.11137
n) (hb: SurjVal.v nav b ≥ n
hb : nav: SurjVal p
nav.v: {R : Type ?u.11164} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b ≥ n: ?m.11137
n) :
nav: SurjVal p
nav.v: {R : Type ?u.11173} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a + b: R
b) ≥ n: ?m.11137
n := Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans (le_min: ∀ {α : Type ?u.11298} [inst : LinearOrder α] {a b c : α}, c ≤ a → c ≤ b → c ≤ min a b
le_min ha: SurjVal.v nav a ≥ n
ha hb: SurjVal.v nav b ≥ n
hb) (nav: SurjVal p
nav.v_add_ge_min_v: ∀ {R : Type ?u.11305} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a + b) ≥ min (SurjVal.v self a) (SurjVal.v self b)
v_add_ge_min_v a: R
a b: R
b)

def nat_of_val: {p : R} → SurjVal p → {a : R} → a ≠ 0 → ℕ
nat_of_val {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.11326} → R → [inst : IntegralDomain R] → Type ?u.11326
SurjVal p: R
p) {a: R
a : R: Type u
R} (h: a ≠ 0
h : a: R
a ≠ 0: ?m.11339
0) : ℕ: Type
ℕ :=
  to_nat: {a : ℕ∪∞} → a ≠ ∞ → ℕ
to_nat ((not_iff_not: ∀ {a b : Prop}, (¬a ↔ ¬b) ↔ (a ↔ b)
not_iff_not.2: ∀ {a b : Prop}, (a ↔ b) → b → a
2 (nav: SurjVal p
nav.v_eq_top_iff_zero: ∀ {R : Type ?u.11404} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero a: R
a)).2: ∀ {a b : Prop}, (a ↔ b) → b → a
2 h: a ≠ 0
h)

/-
lemma val_of_add_one {p : R} (nav : SurjVal p) (h : nav.v x ≥ ofN 1): nav.v (x + 1) = ofN 0 := by
  apply Enat.le_antisymm
  . apply le_of_not_lt
    intro h'
    sorry
  . apply Enat.le_trans _ (nav.v_add_ge_min_v x 1)
    apply le_min (Enat.le_trans (Enat.le_succ 0) h) (le_of_eq (val_of_one nav).symm)
-/

@[simp]
lemma val_of_minus_one: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (nav : SurjVal p), SurjVal.v nav (-1) = ofN 0
val_of_minus_one {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.11498} → R → [inst : IntegralDomain R] → Type ?u.11498
SurjVal p: R
p) : nav: SurjVal p
nav.v: {R : Type ?u.11507} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-1: ?m.11516
1) = ofN: ℕ → ℕ∪∞
ofN 0: ?m.11599
0 := by
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

SurjVal.v nav (-1) = ofN 0cases eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
eq_zero_or_pos (nav: SurjVal p
nav.v: {R : Type ?u.11615} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-1: ?m.11621
1)) with
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

x✝: SurjVal.v nav (-1) = ofN 0 ∨ SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-1) = ofN 0| inl: ∀ {a b : Prop}, a → a ∨ b
inl h: ?m.11659
h => R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) = ofN 0

inlSurjVal.v nav (-1) = ofN 0exact h: ?m.11659
h
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

x✝: SurjVal.v nav (-1) = ofN 0 ∨ SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-1) = ofN 0| inr: ∀ {a b : Prop}, b → a ∨ b
inr h: ?m.11660
h =>
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

inrSurjVal.v nav (-1) = ofN 0have contradiction: SurjVal.v nav 1 > ofN 0
contradiction : nav: SurjVal p
nav.v: {R : Type ?u.11706} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v 1: ?m.11711
1 > ofN: ℕ → ℕ∪∞
ofN 0: ?m.11714
0 := R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

inrSurjVal.v nav (-1) = ofN 0by
      R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0←neg_neg: ∀ {G : Type ?u.11725} [inst : HasInvolutiveNeg G] (a : G), - -a = a
neg_neg 1: ?m.11729
1,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (- -1) > ofN 0 R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0←one_mul: ∀ {M : Type ?u.11829} [inst : MulOneClass M] (a : M), 1 * a = a
one_mul 1: ?m.11833
1,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (- -(1 * 1)) > ofN 0 R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0neg_mul_left: ∀ {R : Type ?u.11926} [inst : Ring R] (a b : R), -(a * b) = -a * b
neg_mul_left,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-(-1 * 1)) > ofN 0 R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0neg_mul_right: ∀ {R : Type ?u.11997} [inst : Ring R] (a b : R), -(a * b) = a * -b
neg_mul_right,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-1 * -1) > ofN 0 R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0nav: SurjVal p
nav.v_mul_eq_add_v: ∀ {R : Type ?u.12021} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_vR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-1) + SurjVal.v nav (-1) > ofN 0]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav (-1) + SurjVal.v nav (-1) > ofN 0
      R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

SurjVal.v nav 1 > ofN 0apply lt_add_right: ∀ (a b c : ℕ∪∞), a < b → a < b + c
lt_add_right _: ℕ∪∞
_ _: ℕ∪∞
_ _: ℕ∪∞
_ h: SurjVal.v nav (-1) > ofN 0
h
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

inrSurjVal.v nav (-1) = ofN 0rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

contradiction: SurjVal.v nav 1 > ofN 0

inrSurjVal.v nav (-1) = ofN 0val_of_one: ∀ {R : Type ?u.12064} [inst : IntegralDomain R] {p : R} (nav : SurjVal p), SurjVal.v nav 1 = ofN 0
val_of_oneR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

contradiction: ofN 0 > ofN 0

inrSurjVal.v nav (-1) = ofN 0]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

contradiction: ofN 0 > ofN 0

inrSurjVal.v nav (-1) = ofN 0 at contradiction: SurjVal.v nav 1 > ofN 0
contradictionR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

contradiction: ofN 0 > ofN 0

inrSurjVal.v nav (-1) = ofN 0
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

h: SurjVal.v nav (-1) > ofN 0

inrSurjVal.v nav (-1) = ofN 0exact False.elim: ∀ {C : Sort ?u.12094}, False → C
False.elim ((lt_irrefl: ∀ {α : Type ?u.12096} [inst : Preorder α] (a : α), ¬a < a
lt_irrefl (ofN: ℕ → ℕ∪∞
ofN 0: ?m.12100
0)) contradiction: ofN 0 > ofN 0
contradiction)
Goals accomplished! 🐙

@[simp]
lemma val_neg: ∀ {x p : R} (nav : SurjVal p), SurjVal.v nav (-x) = SurjVal.v nav x
val_neg {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.12163} → R → [inst : IntegralDomain R] → Type ?u.12163
SurjVal p: R
p) : nav: SurjVal p
nav.v: {R : Type ?u.12169} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-x: ?m.12158
x) = nav: SurjVal p
nav.v: {R : Type ?u.12197} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: ?m.12158
x := by
  R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xrw [R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav x←one_mul: ∀ {M : Type ?u.12208} [inst : MulOneClass M] (a : M), 1 * a = a
one_mul x: R
x,R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-(1 * x)) = SurjVal.v nav (1 * x) R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xneg_mul_left: ∀ {R : Type ?u.12244} [inst : Ring R] (a b : R), -(a * b) = -a * b
neg_mul_left,R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-1 * x) = SurjVal.v nav (1 * x) R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xnav: SurjVal p
nav.v_mul_eq_add_v: ∀ {R : Type ?u.12296} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_v,R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-1) + SurjVal.v nav x = SurjVal.v nav (1 * x) R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xval_of_minus_one: ∀ {R : Type ?u.12316} [inst : IntegralDomain R] {p : R} (nav : SurjVal p), SurjVal.v nav (-1) = ofN 0
val_of_minus_one,R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

ofN 0 + SurjVal.v nav x = SurjVal.v nav (1 * x) R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xone_mul: ∀ {M : Type ?u.12339} [inst : MulOneClass M] (a : M), 1 * a = a
one_mul,R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

ofN 0 + SurjVal.v nav x = SurjVal.v nav x R: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav (-x) = SurjVal.v nav xEnat.zero_add: ∀ (a : ℕ∪∞), ofN 0 + a = a
Enat.zero_addR: Type u

inst✝: IntegralDomain R

x, p: R

nav: SurjVal p

SurjVal.v nav x = SurjVal.v nav x]
Goals accomplished! 🐙

lemma val_sub_ge_of_ge: ∀ {n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R}, SurjVal.v nav a ≥ n → SurjVal.v nav b ≥ n → SurjVal.v nav (a - b) ≥ n
val_sub_ge_of_ge {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.12467} → R → [inst : IntegralDomain R] → Type ?u.12467
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (ha: SurjVal.v nav a ≥ n
ha : nav: SurjVal p
nav.v: {R : Type ?u.12477} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a ≥ n: ?m.12462
n) (hb: SurjVal.v nav b ≥ n
hb : nav: SurjVal p
nav.v: {R : Type ?u.12489} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b ≥ n: ?m.12462
n) :
nav: SurjVal p
nav.v: {R : Type ?u.12498} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a - b: R
b) ≥ n: ?m.12462
n := by
  R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a - b) ≥ nrw [R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a - b) ≥ nsub_eq_add_neg: ∀ {G : Type ?u.12582} [inst : SubNegMonoid G] (a b : G), a - b = a + -b
sub_eq_add_negR: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a + -b) ≥ n]R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a + -b) ≥ n
  R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a - b) ≥ napply val_add_ge_of_ge: ∀ {R : Type ?u.12687} [inst : IntegralDomain R] {n : ℕ∪∞} {p : R} (nav : SurjVal p) {a b : R},
  SurjVal.v nav a ≥ n → SurjVal.v nav b ≥ n → SurjVal.v nav (a + b) ≥ n
val_add_ge_of_geR: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

haSurjVal.v nav a ≥ n
R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

hbSurjVal.v nav (-b) ≥ n
  R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a - b) ≥ nassumptionR: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

hbSurjVal.v nav (-b) ≥ n
  R: Type u

inst✝: IntegralDomain R

n: ℕ∪∞

p: R

nav: SurjVal p

a, b: R

ha: SurjVal.v nav a ≥ n

hb: SurjVal.v nav b ≥ n

SurjVal.v nav (a - b) ≥ nsimpa
Goals accomplished! 🐙

theorem v_add_eq_min_v: ∀ {p : R} (nav : SurjVal p) {a b : R}, SurjVal.v nav a < SurjVal.v nav b → SurjVal.v nav (a + b) = SurjVal.v nav a
v_add_eq_min_v {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.13017} → R → [inst : IntegralDomain R] → Type ?u.13017
SurjVal p: R
p) {a: R
a b: R
b : R: Type u
R} (h: SurjVal.v nav a < SurjVal.v nav b
h : nav: SurjVal p
nav.v: {R : Type ?u.13030} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a < nav: SurjVal p
nav.v: {R : Type ?u.13037} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v b: R
b) :
  nav: SurjVal p
nav.v: {R : Type ?u.13049} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a + b: R
b) = nav: SurjVal p
nav.v: {R : Type ?u.13150} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a := by
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

SurjVal.v nav (a + b) = SurjVal.v nav aapply Enat.le_antisymm: ∀ {n m : ℕ∪∞}, n ≤ m → m ≤ n → n = m
Enat.le_antisymmR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

SurjVal.v nav (a + b) = SurjVal.v nav a.R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)apply le_of_not_lt: ∀ {α : Type ?u.13174} [inst : LinearOrder α] {a b : α}, ¬b < a → a ≤ b
le_of_not_ltR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1.h¬SurjVal.v nav a < SurjVal.v nav (a + b)
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)intro h': SurjVal.v nav a < SurjVal.v nav (a + b)
h'R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

h1.hFalse
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)have hm: SurjVal.v nav a < SurjVal.v nav (-b)
hm : nav: SurjVal p
nav.v: {R : Type ?u.13195} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a < nav: SurjVal p
nav.v: {R : Type ?u.13199} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-b: R
b) := R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

h1.hFalseby R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

SurjVal.v nav a < SurjVal.v nav (-b)rwa [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

SurjVal.v nav a < SurjVal.v nav (-b)val_neg: ∀ {R : Type ?u.13228} [inst : IntegralDomain R] {x p : R} (nav : SurjVal p), SurjVal.v nav (-x) = SurjVal.v nav x
val_negR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

SurjVal.v nav a < SurjVal.v nav b]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

SurjVal.v nav a < SurjVal.v nav b
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)apply lt_irrefl: ∀ {α : Type ?u.13268} [inst : Preorder α] (a : α), ¬a < a
lt_irrefl (nav: SurjVal p
nav.v: {R : Type ?u.13271} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a)R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hSurjVal.v nav a < SurjVal.v nav a
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)apply lt_of_lt_of_le: ∀ {α : Type ?u.13281} [inst : Preorder α] {a b c : α}, a < b → b ≤ c → a < c
lt_of_lt_of_le (lt_min: ∀ {α : Type ?u.13287} [inst : LinearOrder α] {a b c : α}, a < b → a < c → a < min b c
lt_min h': SurjVal.v nav a < SurjVal.v nav (a + b)
h' hm: SurjVal.v nav a < SurjVal.v nav (-b)
hm)R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hmin (SurjVal.v nav (a + b)) (SurjVal.v nav (-b)) ≤ SurjVal.v nav a
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hmin (SurjVal.v nav (a + b)) (SurjVal.v nav (-b)) ≤ SurjVal.v nav a(show nav: SurjVal p
nav.v: {R : Type ?u.13337} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a = nav: SurjVal p
nav.v: {R : Type ?u.13341} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (a: R
a + b: R
b + -b: R
b) by R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hmin (SurjVal.v nav (a + b)) (SurjVal.v nav (-b)) ≤ SurjVal.v nav asimp
Goals accomplished! 🐙)R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hmin (SurjVal.v nav (a + b)) (SurjVal.v nav (-b)) ≤ SurjVal.v nav (a + b + -b)]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h': SurjVal.v nav a < SurjVal.v nav (a + b)

hm: SurjVal.v nav a < SurjVal.v nav (-b)

h1.hmin (SurjVal.v nav (a + b)) (SurjVal.v nav (-b)) ≤ SurjVal.v nav (a + b + -b)
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h1SurjVal.v nav (a + b) ≤ SurjVal.v nav a
R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)exact nav: SurjVal p
nav.v_add_ge_min_v: ∀ {R : Type ?u.13777} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a + b) ≥ min (SurjVal.v self a) (SurjVal.v self b)
v_add_ge_min_v (a: R
a + b: R
b) (-b: R
b)
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

SurjVal.v nav (a + b) = SurjVal.v nav a.R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

a, b: R

h: SurjVal.v nav a < SurjVal.v nav b

h2SurjVal.v nav a ≤ SurjVal.v nav (a + b)exact Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans (le_min: ∀ {α : Type ?u.13837} [inst : LinearOrder α] {a b c : α}, c ≤ a → c ≤ b → c ≤ min a b
le_min (le_of_eq: ∀ {α : Type ?u.13843} [inst : Preorder α] {a b : α}, a = b → a ≤ b
le_of_eq rfl: ∀ {α : Sort ?u.13856} {a : α}, a = a
rfl) (Enat.le_of_lt: ∀ {n m : ℕ∪∞}, n < m → n ≤ m
Enat.le_of_lt h: SurjVal.v nav a < SurjVal.v nav b
h)) (SurjVal.v_add_ge_min_v: ∀ {R : Type ?u.13861} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a + b) ≥ min (SurjVal.v self a) (SurjVal.v self b)
SurjVal.v_add_ge_min_v nav: SurjVal p
nav a: R
a b: R
b)
Goals accomplished! 🐙

theorem val_of_pow_uniformizer: ∀ {n : ℕ} {p : R} (nav : SurjVal p), SurjVal.v nav (p ^ n) = ofN n
val_of_pow_uniformizer {p: R
p : R: Type u
R} (nav: SurjVal p
nav : SurjVal: {R : Type ?u.13888} → R → [inst : IntegralDomain R] → Type ?u.13888
SurjVal p: R
p) : nav: SurjVal p
nav.v: {R : Type ?u.13919} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (p: R
p ^ n: ?m.13908
n) = ofN: ℕ → ℕ∪∞
ofN n: ?m.13908
n := by
  R: Type u

inst✝: IntegralDomain R

n: ℕ

p: R

nav: SurjVal p

SurjVal.v nav (p ^ n) = ofN ninduction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

n: ℕ

p: R

nav: SurjVal p

SurjVal.v nav (p ^ n) = ofN n| zero: ℕ
zero      =>
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

zeroSurjVal.v nav (p ^ Nat.zero) = ofN Nat.zerorw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

zeroSurjVal.v nav (p ^ Nat.zero) = ofN Nat.zeropow_zero: ∀ {M : Type ?u.14057} [inst : Monoid M] (a : M), a ^ 0 = 1
pow_zeroR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

zeroSurjVal.v nav 1 = ofN Nat.zero]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

zeroSurjVal.v nav 1 = ofN Nat.zero
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

zeroSurjVal.v nav (p ^ Nat.zero) = ofN Nat.zeroexact val_of_one: ∀ {R : Type ?u.14150} [inst : IntegralDomain R] {p : R} (nav : SurjVal p), SurjVal.v nav 1 = ofN 0
val_of_one nav: SurjVal p
nav
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

n: ℕ

p: R

nav: SurjVal p

SurjVal.v nav (p ^ n) = ofN n| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.14051 n
ih =>
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)pow_succ: ∀ {M : Type ?u.14171} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p * p ^ n) = ofN (Nat.succ n) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)SurjVal.v_mul_eq_add_v: ∀ {R : Type ?u.14229} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
SurjVal.v_mul_eq_add_v nav: SurjVal p
nav,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav p + SurjVal.v nav (p ^ n) = ofN (Nat.succ n) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)ih: ?m.14051 n
ih,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav p + ofN n = ofN (Nat.succ n) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)SurjVal.v_uniformizer: ∀ {R : Type ?u.14260} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
SurjVal.v_uniformizer nav: SurjVal p
nav,R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succofN 1 + ofN n = ofN (Nat.succ n) R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)add_ofN: ∀ (a b : ℕ), ofN a + ofN b = ofN (a + b)
add_ofNR: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succofN (1 + n) = ofN (Nat.succ n)]R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succofN (1 + n) = ofN (Nat.succ n)
    R: Type u

inst✝: IntegralDomain R

p: R

nav: SurjVal p

n: ℕ

ih: SurjVal.v nav (p ^ n) = ofN n

succSurjVal.v nav (p ^ Nat.succ n) = ofN (Nat.succ n)simp [Nat.succ_eq_add_one: ∀ (n : ℕ), Nat.succ n = n + 1
Nat.succ_eq_add_one, add_comm: ∀ {G : Type ?u.14298} [inst : AddCommSemigroup G] (a b : G), a + b = b + a
add_comm]
Goals accomplished! 🐙

end SurjVal

structure EnatValRing: {R : Type u} →
  {p : R} →
    [inst : IntegralDomain R] →
      (valtn : SurjVal p) →
        (decr_val : R → R) →
          (∀ {x : R}, SurjVal.v valtn x = 0 → decr_val x = x) →
            (∀ {x : R}, SurjVal.v valtn x > 0 → x = p * decr_val x) →
              (residue_char : ℕ) →
                (∀ (n : ℕ), SurjVal.v valtn ↑n > 0 ↔ residue_char ∣ n) → (R → R) → (R → R → R → Bool) → EnatValRing p
EnatValRing {R: Type u
R : Type u: Type (u + 1)
Type u} (p: R
p : R: Type u
R) [IntegralDomain: Type ?u.14523 → Type ?u.14523
IntegralDomain R: Type u
R] where
  valtn: {R : Type u} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn : SurjVal: {R : Type ?u.14528} → R → [inst : IntegralDomain R] → Type ?u.14528
SurjVal p: R
p
  decr_val: {R : Type u} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val : R: Type u
R → R: Type u
R
  zero_valtn_decr: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → EnatValRing.decr_val self x = x
zero_valtn_decr {x: R
x : R: Type u
R} (h: SurjVal.v valtn x = 0
h : valtn: SurjVal p
valtn.v: {R : Type ?u.14543} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = 0: ?m.14551
0) : decr_val: R → R
decr_val x: R
x = x: R
x
  pos_valtn_decr: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * EnatValRing.decr_val self x
pos_valtn_decr {x: R
x : R: Type u
R} (h: SurjVal.v valtn x > 0
h : valtn: SurjVal p
valtn.v: {R : Type ?u.14789} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x > 0: ?m.14794
0) : x: R
x = p: R
p * decr_val: R → R
decr_val x: R
x
  residue_char: {R : Type u} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → ℕ
residue_char : ℕ: Type
ℕ
  def_char: ∀ {R : Type u} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) (n : ℕ),
  SurjVal.v self.valtn ↑n > 0 ↔ self.residue_char ∣ n
def_char : ∀ n: ℕ
n : ℕ: Type
ℕ, valtn: SurjVal p
valtn.v: {R : Type ?u.14919} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (n: ℕ
n : R: Type u
R) > 0: ?m.15002
0 ↔ residue_char: ℕ
residue_char ∣ n: ℕ
n
  norm_repr: {R : Type u} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
norm_repr : R: Type u
R → R: Type u
R --generalization of modulo
  quad_roots_in_residue_field: {R : Type u} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R → R → Bool
quad_roots_in_residue_field : R: Type u
R → R: Type u
R → R: Type u
R → Bool: Type
Bool

namespace EnatValRing

/-- reduce the element x by valuation n (by dividing by an appropriate power of the uniformizer) -/
def sub_val: {p : R} → EnatValRing p → R → ℕ → R
sub_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.16027} → R → [inst : IntegralDomain R] → Type ?u.16027
EnatValRing p: R
p) (x: R
x : R: Type u
R) (n: ℕ
n : ℕ: Type
ℕ) : R: Type u
R :=
  match n: ℕ
n with
  | 0: ℕ
0 => x: R
x
  | Nat.succ: ℕ → ℕ
Nat.succ n: ℕ
n =>
    match evr: EnatValRing p
evr.valtn: {R : Type ?u.16069} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.16076} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x with
    | 0: ℕ∪∞
0 => x: R
x
    | _ => sub_val: {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.16308} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val x: R
x) n: ℕ
n

@[simp]
lemma decr_val_zero: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p), decr_val evr 0 = 0
decr_val_zero {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.16777} → R → [inst : IntegralDomain R] → Type ?u.16777
EnatValRing p: R
p) : evr: EnatValRing p
evr.decr_val: {R : Type ?u.16786} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val 0: ?m.16794
0 = 0: ?m.16846
0 := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

decr_val evr 0 = 0have v_decr_zero: p * decr_val evr 0 = 0
v_decr_zero : p: R
p * evr: EnatValRing p
evr.decr_val: {R : Type ?u.16872} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val 0: ?m.16877
0 = 0: ?m.16880
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

decr_val evr 0 = 0by
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

p * decr_val evr 0 = 0apply Eq.symm: ∀ {α : Sort ?u.16983} {a b : α}, a = b → b = a
Eq.symmR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

h0 = p * decr_val evr 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

p * decr_val evr 0 = 0apply evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.16995} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decrR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

hSurjVal.v evr.valtn 0 > 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

p * decr_val evr 0 = 0rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

hSurjVal.v evr.valtn 0 > 0val_zero: ∀ {R : Type ?u.17006} [inst : IntegralDomain R] {p : R} (nav : SurjVal p), SurjVal.v nav 0 = ∞
val_zeroR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

h∞ > 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

h∞ > 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

p * decr_val evr 0 = 0exact Enat.lt_top: ∀ (n : ℕ), ofN n < ∞
Enat.lt_top 0: ?m.17039
0
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

decr_val evr 0 = 0rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

v_decr_zero: p * decr_val evr 0 = 0

decr_val evr 0 = 0mul_eq_zero_iff_factor_eq_zero: ∀ {R : Type ?u.17053} [inst : IntegralDomain R] (a b : R), a * b = 0 ↔ a = 0 ∨ b = 0
mul_eq_zero_iff_factor_eq_zeroR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

v_decr_zero: p = 0 ∨ decr_val evr 0 = 0

decr_val evr 0 = 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

v_decr_zero: p = 0 ∨ decr_val evr 0 = 0

decr_val evr 0 = 0 at v_decr_zero: p * decr_val evr 0 = 0
v_decr_zeroR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

v_decr_zero: p = 0 ∨ decr_val evr 0 = 0

decr_val evr 0 = 0
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

decr_val evr 0 = 0exact Or.resolve_left: ∀ {a b : Prop}, a ∨ b → ¬a → b
Or.resolve_left v_decr_zero: p = 0 ∨ decr_val evr 0 = 0
v_decr_zero (p_non_zero: ∀ {R : Type ?u.17105} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.17122} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn)
Goals accomplished! 🐙

@[simp]
lemma decr_val_neg: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), decr_val evr (-x) = -decr_val evr x
decr_val_neg {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.17150} → R → [inst : IntegralDomain R] → Type ?u.17150
EnatValRing p: R
p) (x: R
x : R: Type u
R) : evr: EnatValRing p
evr.decr_val: {R : Type ?u.17161} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val (-x: R
x) = -evr: EnatValRing p
evr.decr_val: {R : Type ?u.17193} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val x: R
x := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

decr_val evr (-x) = -decr_val evr xcases eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
eq_zero_or_pos (evr: EnatValRing p
evr.valtn: {R : Type ?u.17206} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.17210} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x) with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

x✝: SurjVal.v evr.valtn x = ofN 0 ∨ SurjVal.v evr.valtn x > ofN 0

decr_val evr (-x) = -decr_val evr x| inl: ∀ {a b : Prop}, a → a ∨ b
inl h: ?m.17238
h =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

inldecr_val evr (-x) = -decr_val evr xhave hm: SurjVal.v evr.valtn (-x) = ofN 0
hm : evr: EnatValRing p
evr.valtn: {R : Type ?u.17270} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.17274} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-x: R
x) = ofN: ℕ → ℕ∪∞
ofN 0: ?m.17282
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

inldecr_val evr (-x) = -decr_val evr xby R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

SurjVal.v evr.valtn (-x) = ofN 0simp [h: SurjVal.v evr.valtn x = ofN 0
h]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

inldecr_val evr (-x) = -decr_val evr xrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

hm: SurjVal.v evr.valtn (-x) = ofN 0

inldecr_val evr (-x) = -decr_val evr xevr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.17490} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr h: ?m.17238
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

hm: SurjVal.v evr.valtn (-x) = ofN 0

inldecr_val evr (-x) = -x R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

hm: SurjVal.v evr.valtn (-x) = ofN 0

inldecr_val evr (-x) = -decr_val evr xevr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.17505} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr hm: SurjVal.v evr.valtn (-x) = ofN 0
hmR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN 0

hm: SurjVal.v evr.valtn (-x) = ofN 0

inl-x = -x]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

x✝: SurjVal.v evr.valtn x = ofN 0 ∨ SurjVal.v evr.valtn x > ofN 0

decr_val evr (-x) = -decr_val evr x| inr: ∀ {a b : Prop}, b → a ∨ b
inr h: ?m.17239
h =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

inrdecr_val evr (-x) = -decr_val evr xhave hm: SurjVal.v evr.valtn (-x) > ofN 0
hm : evr: EnatValRing p
evr.valtn: {R : Type ?u.17534} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.17538} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-x: R
x) > ofN: ℕ → ℕ∪∞
ofN 0: ?m.17546
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

inrdecr_val evr (-x) = -decr_val evr xby R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

SurjVal.v evr.valtn (-x) > ofN 0simp [h: SurjVal.v evr.valtn x > ofN 0
h]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

inrdecr_val evr (-x) = -decr_val evr xapply nzero_mul_left_cancel: ∀ {R : Type ?u.17692} [inst : IntegralDomain R] (a b c : R), a ≠ 0 → a * b = a * c → b = c
nzero_mul_left_cancel p: R
p _: ?m.17693
_ _: ?m.17693
_ (p_non_zero: ∀ {R : Type ?u.17697} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.17717} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = p * -decr_val evr x
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

inrdecr_val evr (-x) = -decr_val evr xrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = p * -decr_val evr x←neg_mul_right: ∀ {R : Type ?u.17725} [inst : Ring R] (a b : R), -(a * b) = a * -b
neg_mul_right,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = -(p * decr_val evr x) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = p * -decr_val evr x←evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.17768} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decr h: ?m.17239
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = -x R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inrp * decr_val evr (-x) = p * -decr_val evr x←evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.17780} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decr hm: SurjVal.v evr.valtn (-x) > ofN 0
hmR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x > ofN 0

hm: SurjVal.v evr.valtn (-x) > ofN 0

inr-x = -x]
Goals accomplished! 🐙

@[simp]
lemma decr_val_p_mul: ∀ {p : R} (evr : EnatValRing p) (x : R), decr_val evr (p * x) = x
decr_val_p_mul {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.17833} → R → [inst : IntegralDomain R] → Type ?u.17833
EnatValRing p: R
p) (x: R
x : R: Type u
R) : evr: EnatValRing p
evr.decr_val: {R : Type ?u.17844} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val (p: R
p * x: R
x) = x: R
x := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

decr_val evr (p * x) = xhave h: p * x = p * decr_val evr (p * x)
h : (p: R
p * x: R
x) = p: R
p * decr_val: {R : Type ?u.17959} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val evr: EnatValRing p
evr (p: R
p * x: R
x) := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

decr_val evr (p * x) = xby
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

p * x = p * decr_val evr (p * x)apply evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.18100} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decrR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

SurjVal.v evr.valtn (p * x) > 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

p * x = p * decr_val evr (p * x)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

SurjVal.v evr.valtn (p * x) > 0evr: EnatValRing p
evr.valtn: {R : Type ?u.18111} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_mul_eq_add_v: ∀ {R : Type ?u.18115} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_v,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

SurjVal.v evr.valtn p + SurjVal.v evr.valtn x > 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

SurjVal.v evr.valtn (p * x) > 0evr: EnatValRing p
evr.valtn: {R : Type ?u.18140} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_uniformizer: ∀ {R : Type ?u.18144} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
v_uniformizerR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

ofN 1 + SurjVal.v evr.valtn x > 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

ofN 1 + SurjVal.v evr.valtn x > 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

p * x = p * decr_val evr (p * x)apply lt_of_lt_of_le: ∀ {α : Type ?u.18161} [inst : Preorder α] {a b c : α}, a < b → b ≤ c → a < c
lt_of_lt_of_le ((Enat.lt_ofN: ∀ (m n : ℕ), m < n ↔ ofN m < ofN n
Enat.lt_ofN 0: ?m.18168
0 1: ?m.18179
1).1: ∀ {a b : Prop}, (a ↔ b) → a → b
1 (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.18196
0)) (Enat.le_add_right: ∀ (n k : ℕ∪∞), n ≤ n + k
Enat.le_add_right (ofN: ℕ → ℕ∪∞
ofN 1: ?m.18201
1) _: ℕ∪∞
_)
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

decr_val evr (p * x) = xapply nzero_mul_left_cancel: ∀ {R : Type ?u.18220} [inst : IntegralDomain R] (a b c : R), a ≠ 0 → a * b = a * c → b = c
nzero_mul_left_cancel p: R
p _: ?m.18221
_ _: ?m.18221
_ (p_non_zero: ∀ {R : Type ?u.18225} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.18242} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: p * x = p * decr_val evr (p * x)

p * decr_val evr (p * x) = p * x
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

decr_val evr (p * x) = xexact h: p * x = p * decr_val evr (p * x)
h.symm: ∀ {α : Sort ?u.18250} {a b : α}, a = b → b = a
symm
Goals accomplished! 🐙

@[simp]
lemma sub_val_zero_n: ∀ {p : R} (evr : EnatValRing p) (n : ℕ), sub_val evr 0 n = 0
sub_val_zero_n {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.18284} → R → [inst : IntegralDomain R] → Type ?u.18284
EnatValRing p: R
p) (n: ℕ
n : ℕ: Type
ℕ) : sub_val: {R : Type ?u.18295} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr 0: ?m.18306
0 n: ℕ
n = 0: ?m.18358
0 := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

n: ℕ

sub_val evr 0 n = 0induction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

n: ℕ

sub_val evr 0 n = 0| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

zerosub_val evr 0 Nat.zero = 0simp [sub_val: {R : Type ?u.18398} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

n: ℕ

sub_val evr 0 n = 0| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.18392 n
ih => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

n: ℕ

ih: sub_val evr 0 n = 0

succsub_val evr 0 (Nat.succ n) = 0simpa [sub_val: {R : Type ?u.19675} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val, decr_val_zero: ∀ {R : Type ?u.19702} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p), decr_val evr 0 = 0
decr_val_zero]
Goals accomplished! 🐙

@[simp]
lemma sub_val_x_zero: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.19764} → R → [inst : IntegralDomain R] → Type ?u.19764
EnatValRing p: R
p) (x: R
x : R: Type u
R) : sub_val: {R : Type ?u.19775} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x 0: ?m.19786
0 = x: R
x := by R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

sub_val evr x 0 = xrfl
Goals accomplished! 🐙

lemma sub_val_val_zero: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.19845} → R → [inst : IntegralDomain R] → Type ?u.19845
EnatValRing p: R
p) (x: R
x : R: Type u
R) (m: ℕ
m : ℕ: Type
ℕ) (h: SurjVal.v evr.valtn x = 0
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.19858} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.19865} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = 0: ?m.19873
0) :
  sub_val: {R : Type ?u.20105} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x m: ℕ
m = x: R
x := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = 0

sub_val evr x m = xcases m: ℕ
m with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = 0

sub_val evr x m = x| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = 0

zerosub_val evr x Nat.zero = xexact sub_val_x_zero: ∀ {R : Type ?u.20156} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero evr: EnatValRing p
evr x: R
x
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = 0

sub_val evr x m = x| succ: ℕ → ℕ
succ m: ℕ
m => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = 0

m: ℕ

succsub_val evr x (Nat.succ m) = xsimp [sub_val: {R : Type ?u.20187} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val, h: SurjVal.v evr.valtn x = 0
h]
Goals accomplished! 🐙

lemma sub_val_val_pos_succ: ∀ {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.20733} → R → [inst : IntegralDomain R] → Type ?u.20733
EnatValRing p: R
p) (x: R
x : R: Type u
R) (m: ℕ
m : ℕ: Type
ℕ) (h: SurjVal.v evr.valtn x ≠ 0
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.20747} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.20754} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≠ 0: ?m.20762
0) :
  sub_val: {R : Type ?u.20980} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x (Nat.succ: ℕ → ℕ
Nat.succ m: ℕ
m) = sub_val: {R : Type ?u.20987} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.20994} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val x: R
x) m: ℕ
m := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x ≠ 0

sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) msimp [sub_val: {R : Type ?u.21007} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val, h: SurjVal.v evr.valtn x ≠ 0
h]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x ≠ 0

(match SurjVal.v evr.valtn x with
  | ofN Nat.zero => x
  | x_1 => sub_val evr (decr_val evr x) m) =   sub_val evr (decr_val evr x) m
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x ≠ 0

sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) mrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x ≠ 0

(match SurjVal.v evr.valtn x with
  | ofN Nat.zero => x
  | x_1 => sub_val evr (decr_val evr x) m) =   sub_val evr (decr_val evr x) mmatch_non_zero: ∀ {β : Sort ?u.22597} (x : ℕ∪∞) {c1 c2 : β},
  x ≠ 0 →
    (match x with
      | ofN Nat.zero => c1
      | x => c2) =       c2
match_non_zero (evr: EnatValRing p
evr.valtn: {R : Type ?u.22599} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.22603} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x) h: SurjVal.v evr.valtn x ≠ 0
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x ≠ 0

sub_val evr (decr_val evr x) m = sub_val evr (decr_val evr x) m]
Goals accomplished! 🐙


lemma val_decr_val: ∀ {m : ℕ} {p : R} (evr : EnatValRing p) (x : R),
  SurjVal.v evr.valtn x = ofN m → SurjVal.v evr.valtn (decr_val evr x) = ofN (m - 1)
val_decr_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.22694} → R → [inst : IntegralDomain R] → Type ?u.22694
EnatValRing p: R
p) (x: R
x : R: Type u
R) (h: SurjVal.v evr.valtn x = ofN m
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.22702} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.22706} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = ofN: ℕ → ℕ∪∞
ofN m: ?m.22689
m) :
  evr: EnatValRing p
evr.valtn: {R : Type ?u.22714} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.22718} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (evr: EnatValRing p
evr.decr_val: {R : Type ?u.22722} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val x: R
x) = ofN: ℕ → ℕ∪∞
ofN (m: ?m.22689
m - 1: ?m.22730
1) := by
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (decr_val evr x) = ofN (m - 1)cases m: ℕ
m with
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (decr_val evr x) = ofN (m - 1)| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN Nat.zero

zeroSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.zero - 1)rwa [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN Nat.zero

zeroSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.zero - 1)evr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.22838} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr h: SurjVal.v evr.valtn x = ofN Nat.zero
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN Nat.zero

zeroSurjVal.v evr.valtn x = ofN (Nat.zero - 1)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN Nat.zero

zeroSurjVal.v evr.valtn x = ofN (Nat.zero - 1)
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (decr_val evr x) = ofN (m - 1)| succ: ℕ → ℕ
succ m: ℕ
m =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

succSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.succ m - 1)have x_pos_val: SurjVal.v evr.valtn x > ofN 0
x_pos_val : evr: EnatValRing p
evr.valtn: {R : Type ?u.22879} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.22883} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x > ofN: ℕ → ℕ∪∞
ofN 0: ?m.22888
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

succSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.succ m - 1)by
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

SurjVal.v evr.valtn x > ofN 0rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

SurjVal.v evr.valtn x > ofN 0h: SurjVal.v evr.valtn x = ofN (Nat.succ m)
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ofN (Nat.succ m) > ofN 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ofN (Nat.succ m) > ofN 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

SurjVal.v evr.valtn x > ofN 0exact succ_pos: ∀ (n : ℕ∪∞), ofN 0 < succ n
succ_pos (ofN: ℕ → ℕ∪∞
ofN m: ℕ
m)
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

succSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.succ m - 1)apply add_right_cancel_ofN: ∀ (a : ℕ) (b c : ℕ∪∞), b + ofN a = c + ofN a → b = c
add_right_cancel_ofN 1: ?m.22927
1R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

succSurjVal.v evr.valtn (decr_val evr x) = ofN (Nat.succ m - 1)rwa [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1add_ofN: ∀ (a b : ℕ), ofN a + ofN b = ofN (a + b)
add_ofN,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1 + 1) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1←evr: EnatValRing p
evr.valtn: {R : Type ?u.22958} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_uniformizer: ∀ {R : Type ?u.22962} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
v_uniformizer,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + SurjVal.v evr.valtn p = ofN (Nat.succ m - 1 + 1) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1←evr: EnatValRing p
evr.valtn: {R : Type ?u.22975} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_mul_eq_add_v: ∀ {R : Type ?u.22979} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
v_mul_eq_add_v,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x * p) = ofN (Nat.succ m - 1 + 1) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1mul_comm: ∀ {G : Type ?u.23017} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_comm,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (p * decr_val evr x) = ofN (Nat.succ m - 1 + 1)
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1←evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.23084} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decr x_pos_val: SurjVal.v evr.valtn x > ofN 0
x_pos_val,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn x = ofN (Nat.succ m - 1 + 1) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn (decr_val evr x) + ofN 1 = ofN (Nat.succ m - 1) + ofN 1Nat.succ_sub_one: ∀ (n : ℕ), Nat.succ n - 1 = n
Nat.succ_sub_oneR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn x = ofN (m + 1)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

x_pos_val: SurjVal.v evr.valtn x > ofN 0

succ.aSurjVal.v evr.valtn x = ofN (m + 1)

lemma sub_val_decr_val_comm: ∀ {p : R} (evr : EnatValRing p) (x : R) (n : ℕ), sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)
sub_val_decr_val_comm {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.23144} → R → [inst : IntegralDomain R] → Type ?u.23144
EnatValRing p: R
p) (x: R
x : R: Type u
R) (n: ℕ
n : ℕ: Type
ℕ) : sub_val: {R : Type ?u.23157} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.23167} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val x: R
x) n: ℕ
n = evr: EnatValRing p
evr.decr_val: {R : Type ?u.23171} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val (sub_val: {R : Type ?u.23175} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)have general: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)
general : ∀ a: ?m.23189
a, sub_val: {R : Type ?u.23193} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.23200} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: ?m.23189
a) n: ℕ
n = evr: EnatValRing p
evr.decr_val: {R : Type ?u.23204} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val (sub_val: {R : Type ?u.23208} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr a: ?m.23189
a n: ℕ
n) := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)by
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)induction n: ℕ
n with
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)| zero: ℕ
zero =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zero∀ (a : R), sub_val evr (decr_val evr a) Nat.zero = decr_val evr (sub_val evr a Nat.zero)simp [sub_val_x_zero: ∀ {R : Type ?u.23236} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.23229 n
ih =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

succ∀ (a : R), sub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))intro a: R
aR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

succsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

succ∀ (a : R), sub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))cases Enat.eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
Enat.eq_zero_or_pos (evr: EnatValRing p
evr.valtn: {R : Type ?u.23683} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.23687} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a) with
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

x✝: SurjVal.v evr.valtn a = ofN 0 ∨ SurjVal.v evr.valtn a > ofN 0

succsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))| inl: ∀ {a b : Prop}, a → a ∨ b
inl h: ?m.23715
h =>
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))evr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.23745} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr h: ?m.23715
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inlsub_val evr a (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_zero: ∀ {R : Type ?u.23760} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr a: R
a n: ℕ
n.succ: ℕ → ℕ
succ h: ?m.23715
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inla = decr_val evr a R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))evr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.23771} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr h: ?m.23715
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a = ofN 0

succ.inla = a]
Goals accomplished! 🐙
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

x✝: SurjVal.v evr.valtn a = ofN 0 ∨ SurjVal.v evr.valtn a > ofN 0

succsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))| inr: ∀ {a b : Prop}, b → a ∨ b
inr h: ?m.23716
h =>
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

succ.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))cases Enat.eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
Enat.eq_zero_or_pos (evr: EnatValRing p
evr.valtn: {R : Type ?u.23798} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.23802} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (evr: EnatValRing p
evr.decr_val: {R : Type ?u.23806} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a)) with
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

x✝: SurjVal.v evr.valtn (decr_val evr a) = ofN 0 ∨ SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))| inl: ∀ {a b : Prop}, a → a ∨ b
inl h': ?m.23829
h' =>
          R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_zero: ∀ {R : Type ?u.23859} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.23866} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a) n: ℕ
n.succ: ℕ → ℕ
succ h': ?m.23829
h',R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inldecr_val evr a = decr_val evr (sub_val evr a (Nat.succ n)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_pos_succ: ∀ {R : Type ?u.23874} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr a: R
a n: ℕ
n (ne_of_gt: ∀ {α : Type ?u.23881} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h: ?m.23716
h),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inldecr_val evr a = decr_val evr (sub_val evr (decr_val evr a) n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))←ih: ?m.23229 n
ih (evr: EnatValRing p
evr.decr_val: {R : Type ?u.23902} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inldecr_val evr a = sub_val evr (decr_val evr (decr_val evr a)) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))evr: EnatValRing p
evr.zero_valtn_decr: ∀ {R : Type ?u.23909} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x = 0 → decr_val self x = x
zero_valtn_decr h': ?m.23829
h',R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inldecr_val evr a = sub_val evr (decr_val evr a) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inlsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_zero: ∀ {R : Type ?u.23917} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.23924} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a) n: ℕ
n h': ?m.23829
h'R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) = ofN 0

succ.inr.inldecr_val evr a = decr_val evr a]
Goals accomplished! 🐙
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

x✝: SurjVal.v evr.valtn (decr_val evr a) = ofN 0 ∨ SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))| inr: ∀ {a b : Prop}, b → a ∨ b
inr h': ?m.23830
h' =>
          R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_pos_succ: ∀ {R : Type ?u.23950} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr (evr: EnatValRing p
evr.decr_val: {R : Type ?u.23957} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a) n: ℕ
n (ne_of_gt: ∀ {α : Type ?u.23961} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h': ?m.23830
h'),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrsub_val evr (decr_val evr (decr_val evr a)) n = decr_val evr (sub_val evr a (Nat.succ n)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))ih: ?m.23229 n
ih (evr: EnatValRing p
evr.decr_val: {R : Type ?u.23970} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val a: R
a),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrdecr_val evr (sub_val evr (decr_val evr a) n) = decr_val evr (sub_val evr a (Nat.succ n)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrsub_val evr (decr_val evr a) (Nat.succ n) = decr_val evr (sub_val evr a (Nat.succ n))sub_val_val_pos_succ: ∀ {R : Type ?u.23977} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr a: R
a n: ℕ
n (ne_of_gt: ∀ {α : Type ?u.23984} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h: ?m.23716
h)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)

a: R

h: SurjVal.v evr.valtn a > ofN 0

h': SurjVal.v evr.valtn (decr_val evr a) > ofN 0

succ.inr.inrdecr_val evr (sub_val evr (decr_val evr a) n) = decr_val evr (sub_val evr (decr_val evr a) n)]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)exact general: ∀ (a : R), sub_val evr (decr_val evr a) n = decr_val evr (sub_val evr a n)
general x: R
x
Goals accomplished! 🐙

lemma val_sub_val_eq: ∀ {m : ℕ} {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  SurjVal.v evr.valtn x = ofN m → SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)
val_sub_val_eq {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.24086} → R → [inst : IntegralDomain R] → Type ?u.24086
EnatValRing p: R
p) (x: R
x : R: Type u
R) (n: ℕ
n : ℕ: Type
ℕ) (h: SurjVal.v evr.valtn x = ofN m
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.24096} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.24100} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = ofN: ℕ → ℕ∪∞
ofN m: ?m.24081
m) :
  evr: EnatValRing p
evr.valtn: {R : Type ?u.24108} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.24112} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (sub_val: {R : Type ?u.24116} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) = ofN: ℕ → ℕ∪∞
ofN (m: ?m.24081
m - n: ℕ
n) := by
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)induction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn (sub_val evr x Nat.zero) = ofN (m - Nat.zero)rwa [R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn (sub_val evr x Nat.zero) = ofN (m - Nat.zero)sub_val_x_zero: ∀ {R : Type ?u.24188} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero,R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn x = ofN (m - Nat.zero) R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn (sub_val evr x Nat.zero) = ofN (m - Nat.zero)Nat.sub_zero: ∀ (n : ℕ), n - 0 = n
Nat.sub_zeroR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn x = ofN m]R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

zeroSurjVal.v evr.valtn x = ofN m
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN m

SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.24182 n
ih =>
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

n: ℕ

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)

succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (m - Nat.succ n)cases m: ℕ
m with
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

n: ℕ

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)

succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (m - Nat.succ n)| zero: ℕ
zero =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.zero - n)

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.zero - n)

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)Nat.zero_sub: ∀ (n : ℕ), 0 - n = 0
Nat.zero_subR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n) at ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.zero - n)
ihR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.zero - n)

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)Nat.zero_sub: ∀ (n : ℕ), 0 - n = 0
Nat.zero_sub,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)sub_val_val_zero: ∀ {R : Type ?u.24295} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr x: R
x n: ℕ
n.succ: ℕ → ℕ
succ h: SurjVal.v evr.valtn x = ofN Nat.zero
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn x = ofN 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN 0

succ.zeroSurjVal.v evr.valtn x = ofN 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x = ofN Nat.zero

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.zero - n)

succ.zeroSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.zero - Nat.succ n)exact h: SurjVal.v evr.valtn x = ofN Nat.zero
h
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x = ofN m

n: ℕ

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)

succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (m - Nat.succ n)| succ: ℕ → ℕ
succ m: ℕ
m =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)sub_val_val_pos_succ: ∀ {R : Type ?u.24333} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr (decr_val evr x) n) = ofN (Nat.succ m - Nat.succ n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)sub_val_decr_val_comm: ∀ {R : Type ?u.24351} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)
sub_val_decr_val_comm,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (decr_val evr (sub_val evr x n)) = ofN (Nat.succ m - Nat.succ n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)val_decr_val: ∀ {R : Type ?u.24372} [inst : IntegralDomain R] {m : ℕ} {p : R} (evr : EnatValRing p) (x : R),
  SurjVal.v evr.valtn x = ofN m → SurjVal.v evr.valtn (decr_val evr x) = ofN (m - 1)
val_decr_val evr: EnatValRing p
evr (sub_val: {R : Type ?u.24380} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)
ih,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succofN (Nat.succ m - n - 1) = ofN (Nat.succ m - Nat.succ n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)←eq_ofN: ∀ (m n : ℕ), m = n ↔ ofN m = ofN n
eq_ofN,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succNat.succ m - n - 1 = Nat.succ m - Nat.succ n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)Nat.succ_eq_add_one: ∀ (n : ℕ), Nat.succ n = n + 1
Nat.succ_eq_add_one n: ℕ
n,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succNat.succ m - n - 1 = Nat.succ m - (n + 1)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)Nat.sub_sub: ∀ (n m k : ℕ), n - m - k = n - (m + k)
Nat.sub_subR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succNat.succ m - (n + 1) = Nat.succ m - (n + 1)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0h: SurjVal.v evr.valtn x = ofN (Nat.succ m)
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hofN (Nat.succ m) ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hSurjVal.v evr.valtn x ≠ 0(show 0: ?m.24420
0 = ofN: ℕ → ℕ∪∞
ofN 0: ?m.24436
0 by R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hofN (Nat.succ m) ≠ 0rfl
Goals accomplished! 🐙)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hofN (Nat.succ m) ≠ ofN 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succ.hofN (Nat.succ m) ≠ ofN 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

h: SurjVal.v evr.valtn x = ofN (Nat.succ m)

ih: SurjVal.v evr.valtn (sub_val evr x n) = ofN (Nat.succ m - n)

succ.succSurjVal.v evr.valtn (sub_val evr x (Nat.succ n)) = ofN (Nat.succ m - Nat.succ n)simp [←eq_ofN: ∀ (m n : ℕ), m = n ↔ ofN m = ofN n
eq_ofN]
Goals accomplished! 🐙

lemma val_sub_val_le: ∀ {m : ℕ} {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  SurjVal.v evr.valtn x ≥ ofN m → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
val_sub_val_le {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.24824} → R → [inst : IntegralDomain R] → Type ?u.24824
EnatValRing p: R
p) (x: R
x : R: Type u
R) (n: ℕ
n : ℕ: Type
ℕ) (h: SurjVal.v evr.valtn x ≥ ofN m
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.24834} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.24838} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN m: ?m.24819
m) : evr: EnatValRing p
evr.valtn: {R : Type ?u.24850} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.24854} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (sub_val: {R : Type ?u.24858} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) ≥ ofN: ℕ → ℕ∪∞
ofN (m: ?m.24819
m - n: ℕ
n) := by
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)cases enat_disjunction: ∀ (a : ℕ∪∞), a = ∞ ∨ ∃ n, a = ofN n
enat_disjunction (evr: EnatValRing p
evr.valtn: {R : Type ?u.24919} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.24923} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x) with
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

x✝: SurjVal.v evr.valtn x = ∞ ∨ ∃ n, SurjVal.v evr.valtn x = ofN n

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)| inl: ∀ {a b : Prop}, a → a ∨ b
inl h': ?m.24950
h' =>
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)have topcase: x = 0
topcase : x: R
x = 0: ?m.24983
0 := (evr: EnatValRing p
evr.valtn: {R : Type ?u.25047} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_eq_top_iff_zero: ∀ {R : Type ?u.25051} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero x: R
x).1: ∀ {a b : Prop}, (a ↔ b) → a → b
1 h': ?m.24950
h'R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)rw [R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)topcase: x = 0
topcase,R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn (sub_val evr 0 n) ≥ ofN (m - n) R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)sub_val_zero_n: ∀ {R : Type ?u.25069} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (n : ℕ), sub_val evr 0 n = 0
sub_val_zero_n,R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn 0 ≥ ofN (m - n) R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)(evr: EnatValRing p
evr.valtn: {R : Type ?u.25092} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_eq_top_iff_zero: ∀ {R : Type ?u.25096} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a : R), SurjVal.v self a = ∞ ↔ a = 0
v_eq_top_iff_zero 0: ?m.25101
0).2: ∀ {a b : Prop}, (a ↔ b) → b → a
2 rfl: ∀ {α : Sort ?u.25105} {a : α}, a = a
rflR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inl∞ ≥ ofN (m - n)]R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

topcase: x = 0

inl∞ ≥ ofN (m - n)
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': SurjVal.v evr.valtn x = ∞

inlSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)exact le.below_top: ∀ {n : ℕ∪∞}, Enat.le n ∞
le.below_top
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

x✝: SurjVal.v evr.valtn x = ∞ ∨ ∃ n, SurjVal.v evr.valtn x = ofN n

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)| inr: ∀ {a b : Prop}, b → a ∨ b
inr h': ?m.24951
h' =>
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

inrSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)have H: ∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
H : ∀ (a: ℕ
a : ℕ: Type
ℕ), evr: EnatValRing p
evr.valtn: {R : Type ?u.25139} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.25143} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = ofN: ℕ → ℕ∪∞
ofN a: ℕ
a → evr: EnatValRing p
evr.valtn: {R : Type ?u.25150} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.25154} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (sub_val: {R : Type ?u.25158} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) ≥ ofN: ℕ → ℕ∪∞
ofN (m: ℕ
m - n: ℕ
n) := R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

inrSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)by
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)intro a: ℕ
a ha: SurjVal.v evr.valtn x = ofN a
haR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)have h'': ?m.25201
h'' := val_sub_val_eq: ∀ {R : Type ?u.25202} [inst : IntegralDomain R] {m : ℕ} {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  SurjVal.v evr.valtn x = ofN m → SurjVal.v evr.valtn (sub_val evr x n) = ofN (m - n)
val_sub_val_eq evr: EnatValRing p
evr x: R
x n: ℕ
n ha: SurjVal.v evr.valtn x = ofN a
haR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)rw [R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)h'': ?m.25201
h''R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

ofN (a - n) ≥ ofN (m - n)]R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

ofN (a - n) ≥ ofN (m - n)
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)apply (le_ofN: ∀ (m n : ℕ), m ≤ n ↔ ofN m ≤ ofN n
le_ofN (m: ℕ
m - n: ℕ
n) (a: ℕ
a - n: ℕ
n)).1: ∀ {a b : Prop}, (a ↔ b) → a → b
1R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

m - n ≤ a - n
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)rw [R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

m - n ≤ a - nha: SurjVal.v evr.valtn x = ofN a
haR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

h: ofN a ≥ ofN m

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

m - n ≤ a - n]R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

h: ofN a ≥ ofN m

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

m - n ≤ a - n at h: SurjVal.v evr.valtn x ≥ ofN m
hR: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h': ∃ n, SurjVal.v evr.valtn x = ofN n

a: ℕ

h: ofN a ≥ ofN m

ha: SurjVal.v evr.valtn x = ofN a

h'': SurjVal.v evr.valtn (sub_val evr x n) = ofN (a - n)

m - n ≤ a - n
      R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)apply Nat.sub_le_sub_right: ∀ {n m : ℕ}, n ≤ m → ∀ (k : ℕ), n - k ≤ m - k
Nat.sub_le_sub_right ((le_ofN: ∀ (m n : ℕ), m ≤ n ↔ ofN m ≤ ofN n
le_ofN m: ℕ
m a: ℕ
a).2: ∀ {a b : Prop}, (a ↔ b) → b → a
2 h: ofN a ≥ ofN m
h)
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

m: ℕ

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN m

h': ∃ n, SurjVal.v evr.valtn x = ofN n

inrSurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)exact Exists.elim: ∀ {α : Sort ?u.25319} {p : α → Prop} {b : Prop}, (∃ x, p x) → (∀ (a : α), p a → b) → b
Exists.elim h': ?m.24951
h' H: ∀ (a : ℕ), SurjVal.v evr.valtn x = ofN a → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
H
Goals accomplished! 🐙

lemma factor_p_of_le_val: ∀ {p : R} (evr : EnatValRing p) {x : R} {n : ℕ}, SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.25381} → R → [inst : IntegralDomain R] → Type ?u.25381
EnatValRing p: R
p) {x: R
x : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (h: SurjVal.v evr.valtn x ≥ ofN n
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.25394} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.25401} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) :
  x: R
x = p: R
p ^ n: ℕ
n * sub_val: {R : Type ?u.25422} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN n

x = p ^ n * sub_val evr x ninduction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN n

x = p ^ n * sub_val evr x n| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

h: SurjVal.v evr.valtn x ≥ ofN Nat.zero

zerox = p ^ Nat.zero * sub_val evr x Nat.zerosimp [sub_val: {R : Type ?u.25667} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

h: SurjVal.v evr.valtn x ≥ ofN n

x = p ^ n * sub_val evr x n| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.25657 n
ih =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)sub_val_val_pos_succ: ∀ {R : Type ?u.25927} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr (decr_val evr x) n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)sub_val_decr_val_comm: ∀ {R : Type ?u.25945} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)
sub_val_decr_val_comm,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * decr_val evr (sub_val evr x n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)pow_succ': ∀ {M : Type ?u.25966} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a ^ n * a
pow_succ',R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ n * p * decr_val evr (sub_val evr x n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)mul_assoc: ∀ {G : Type ?u.26024} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assocR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ n * (p * decr_val evr (sub_val evr x n))
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ n * (p * decr_val evr (sub_val evr x n))
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)have pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0
pos_val : evr: EnatValRing p
evr.valtn: {R : Type ?u.26128} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.26132} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (sub_val: {R : Type ?u.26136} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n) > 0: ?m.26141
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ n * (p * decr_val evr (sub_val evr x n))
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0by
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

SurjVal.v evr.valtn (sub_val evr x n) > 0have h': ?m.26379
h' := val_sub_val_le: ∀ {R : Type ?u.26380} [inst : IntegralDomain R] {m : ℕ} {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  SurjVal.v evr.valtn x ≥ ofN m → SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (m - n)
val_sub_val_le evr: EnatValRing p
evr x: R
x n: ℕ
n h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (Nat.succ n - n)

SurjVal.v evr.valtn (sub_val evr x n) > 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

SurjVal.v evr.valtn (sub_val evr x n) > 0rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (Nat.succ n - n)

SurjVal.v evr.valtn (sub_val evr x n) > 0Nat.succ_eq_add_one: ∀ (n : ℕ), Nat.succ n = n + 1
Nat.succ_eq_add_one,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (n + 1 - n)

SurjVal.v evr.valtn (sub_val evr x n) > 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (Nat.succ n - n)

SurjVal.v evr.valtn (sub_val evr x n) > 0Nat.add_sub_self_left: ∀ (a b : ℕ), a + b - a = b
Nat.add_sub_self_leftR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN 1

SurjVal.v evr.valtn (sub_val evr x n) > 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN 1

SurjVal.v evr.valtn (sub_val evr x n) > 0 at h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN (n + 1 - n)
h'R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN 1

SurjVal.v evr.valtn (sub_val evr x n) > 0
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

SurjVal.v evr.valtn (sub_val evr x n) > 0exact lt_of_succ_le: ∀ {n : ℕ} {m : ℕ∪∞}, succ (ofN n) ≤ m → ofN n < m
lt_of_succ_le h': SurjVal.v evr.valtn (sub_val evr x n) ≥ ofN 1
h'
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0

succx = p ^ n * (p * decr_val evr (sub_val evr x n))
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0←evr: EnatValRing p
evr.pos_valtn_decr: ∀ {R : Type ?u.26464} {p : R} [inst : IntegralDomain R] (self : EnatValRing p) {x : R},
  SurjVal.v self.valtn x > 0 → x = p * decr_val self x
pos_valtn_decr pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0
pos_valR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0

succx = p ^ n * sub_val evr x n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0

succx = p ^ n * sub_val evr x n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)apply ih: ?m.25657 n
ihR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

pos_val: SurjVal.v evr.valtn (sub_val evr x n) > 0

succSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)exact le_of_succ_le: ∀ {n m : ℕ∪∞}, succ n ≤ m → n ≤ m
le_of_succ_le h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.hSurjVal.v evr.valtn x ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)apply ne_of_gt: ∀ {α : Type ?u.26502} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gtR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.h.h0 < SurjVal.v evr.valtn x
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succ.h.h0 < SurjVal.v evr.valtn x←succ_ofN: ∀ (a : ℕ), succ (ofN a) = ofN (Nat.succ a)
succ_ofNR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ succ (ofN n)

succ.h.h0 < SurjVal.v evr.valtn x]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ succ (ofN n)

succ.h.h0 < SurjVal.v evr.valtn x at h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)
hR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ succ (ofN n)

succ.h.h0 < SurjVal.v evr.valtn x
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n

h: SurjVal.v evr.valtn x ≥ ofN (Nat.succ n)

succx = p ^ Nat.succ n * sub_val evr x (Nat.succ n)exact lt_of_lt_of_le: ∀ {α : Type ?u.26541} [inst : Preorder α] {a b c : α}, a < b → b ≤ c → a < c
lt_of_lt_of_le (succ_pos: ∀ (n : ℕ∪∞), ofN 0 < succ n
succ_pos (ofN: ℕ → ℕ∪∞
ofN n: ℕ
n)) h: SurjVal.v evr.valtn x ≥ succ (ofN n)
h
Goals accomplished! 🐙

lemma factor_p_of_eq_val: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x = ofN n → x = p ^ n * sub_val evr x n
factor_p_of_eq_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.26581} → R → [inst : IntegralDomain R] → Type ?u.26581
EnatValRing p: R
p) {x: R
x : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (h: SurjVal.v evr.valtn x = ofN n
h : evr: EnatValRing p
evr.valtn: {R : Type ?u.26594} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.26601} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x = ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) :
x: R
x = p: R
p ^ n: ℕ
n * sub_val: {R : Type ?u.26618} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n := factor_p_of_le_val: ∀ {R : Type ?u.26838} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (le_of_eq: ∀ {α : Type ?u.26868} [inst : Preorder α] {a b : α}, a = b → a ≤ b
le_of_eq (Eq.symm: ∀ {α : Sort ?u.26879} {a b : α}, a = b → b = a
Eq.symm h: SurjVal.v evr.valtn x = ofN n
h))

lemma sub_val_p_mul: ∀ {p : R} (evr : EnatValRing p) (x : R) (n : ℕ), sub_val evr (p ^ n * x) n = x
sub_val_p_mul {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.26901} → R → [inst : IntegralDomain R] → Type ?u.26901
EnatValRing p: R
p) (x: R
x : R: Type u
R) (n: ℕ
n : ℕ: Type
ℕ) : sub_val: {R : Type ?u.26914} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (p: R
p ^ n: ℕ
n * x: R
x) n: ℕ
n = x: R
x := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (p ^ n * x) n = xinduction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (p ^ n * x) n = x| zero: ℕ
zero      =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (p ^ Nat.zero * x) Nat.zero = xrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (p ^ Nat.zero * x) Nat.zero = xpow_zero: ∀ {M : Type ?u.27162} [inst : Monoid M] (a : M), a ^ 0 = 1
pow_zero,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (1 * x) Nat.zero = x R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (p ^ Nat.zero * x) Nat.zero = xone_mul: ∀ {M : Type ?u.27251} [inst : MulOneClass M] (a : M), 1 * a = a
one_mulR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr x Nat.zero = x]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr x Nat.zero = x
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (p ^ Nat.zero * x) Nat.zero = xexact sub_val_x_zero: ∀ {R : Type ?u.27351} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero evr: EnatValRing p
evr x: R
x
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (p ^ n * x) n = x| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.27156 n
ih =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xsub_val_val_pos_succ: ∀ {R : Type ?u.27374} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (decr_val evr (p ^ Nat.succ n * x)) n = x
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xpow_succ: ∀ {M : Type ?u.27396} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (decr_val evr (p * p ^ n * x)) n = x
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xmul_assoc: ∀ {G : Type ?u.27454} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (decr_val evr (p * (p ^ n * x))) n = x
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xdecr_val_p_mul: ∀ {R : Type ?u.27552} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), decr_val evr (p * x) = x
decr_val_p_mulR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ n * x) n = x
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ n * x) n = x
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xexact ih: ?m.27156 n
ihR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.hSurjVal.v evr.valtn (p ^ Nat.succ n * x) ≠ 0
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xapply ne_of_gt: ∀ {α : Type ?u.27579} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gtR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h0 < SurjVal.v evr.valtn (p ^ Nat.succ n * x)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xapply lt_of_succ_le: ∀ {n : ℕ} {m : ℕ∪∞}, succ (ofN n) ≤ m → ofN n < m
lt_of_succ_leR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p ^ Nat.succ n * x)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p ^ Nat.succ n * x)pow_succ: ∀ {M : Type ?u.27609} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p * p ^ n * x) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p ^ Nat.succ n * x)mul_assoc: ∀ {G : Type ?u.27667} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p * (p ^ n * x)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p ^ Nat.succ n * x)succ_ofN: ∀ (a : ℕ), succ (ofN a) = ofN (Nat.succ a)
succ_ofN,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hofN (Nat.succ Nat.zero) ≤ SurjVal.v evr.valtn (p * (p ^ n * x)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hsucc (ofN Nat.zero) ≤ SurjVal.v evr.valtn (p ^ Nat.succ n * x)←evr: EnatValRing p
evr.valtn: {R : Type ?u.27742} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_uniformizer: ∀ {R : Type ?u.27746} {p : R} [inst : IntegralDomain R] (self : SurjVal p), SurjVal.v self p = ofN 1
v_uniformizerR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hSurjVal.v evr.valtn p ≤ SurjVal.v evr.valtn (p * (p ^ n * x))]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succ.h.h.hSurjVal.v evr.valtn p ≤ SurjVal.v evr.valtn (p * (p ^ n * x))
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (p ^ n * x) n = x

succsub_val evr (p ^ Nat.succ n * x) (Nat.succ n) = xapply val_mul_ge_left: ∀ {R : Type ?u.27760} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R),
  SurjVal.v nav (a * b) ≥ SurjVal.v nav a
val_mul_ge_left evr: EnatValRing p
evr.valtn: {R : Type ?u.27764} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn
Goals accomplished! 🐙

lemma sub_val_neg: ∀ {p : R} (evr : EnatValRing p) {x : R} {n : ℕ}, sub_val evr (-x) n = -sub_val evr x n
sub_val_neg {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.27819} → R → [inst : IntegralDomain R] → Type ?u.27819
EnatValRing p: R
p) {x: R
x : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} : sub_val: {R : Type ?u.27832} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (-x: R
x) n: ℕ
n = -sub_val: {R : Type ?u.27867} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (-x) n = -sub_val evr x ninduction n: ℕ
n with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (-x) n = -sub_val evr x n| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

zerosub_val evr (-x) Nat.zero = -sub_val evr x Nat.zerosimp [sub_val_x_zero: ∀ {R : Type ?u.27902} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

sub_val evr (-x) n = -sub_val evr x n| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.27896 n
ih =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

succsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)cases eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
eq_zero_or_pos (evr: EnatValRing p
evr.valtn: {R : Type ?u.28012} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.28016} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x) with
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

x✝: SurjVal.v evr.valtn x = ofN 0 ∨ SurjVal.v evr.valtn x > ofN 0

succsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)| inl: ∀ {a b : Prop}, a → a ∨ b
inl h': ?m.28044
h' =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)have h'm: SurjVal.v evr.valtn (-x) = ofN 0
h'm : evr: EnatValRing p
evr.valtn: {R : Type ?u.28076} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.28080} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-x: R
x) = ofN: ℕ → ℕ∪∞
ofN 0: ?m.28088
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)by R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

SurjVal.v evr.valtn (-x) = ofN 0simp [h': SurjVal.v evr.valtn x = ofN 0
h']
Goals accomplished! 🐙
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

h'm: SurjVal.v evr.valtn (-x) = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_val_zero: ∀ {R : Type ?u.28266} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr _: ?m.28267
_ _: ℕ
_ h': ?m.28044
h',R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

h'm: SurjVal.v evr.valtn (-x) = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -x R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

h'm: SurjVal.v evr.valtn (-x) = ofN 0

succ.inlsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_val_zero: ∀ {R : Type ?u.28284} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr _: ?m.28285
_ _: ℕ
_ h'm: SurjVal.v evr.valtn (-x) = ofN 0
h'mR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x = ofN 0

h'm: SurjVal.v evr.valtn (-x) = ofN 0

succ.inl-x = -x]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

x✝: SurjVal.v evr.valtn x = ofN 0 ∨ SurjVal.v evr.valtn x > ofN 0

succsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)| inr: ∀ {a b : Prop}, b → a ∨ b
inr h': ?m.28045
h' =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)have h'm: SurjVal.v evr.valtn (-x) > ofN 0
h'm : evr: EnatValRing p
evr.valtn: {R : Type ?u.28317} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.28321} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (-x: R
x) > ofN: ℕ → ℕ∪∞
ofN 0: ?m.28329
0 := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)by R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

SurjVal.v evr.valtn (-x) > ofN 0simp [h': SurjVal.v evr.valtn x > ofN 0
h']
Goals accomplished! 🐙
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_val_pos_succ: ∀ {R : Type ?u.28472} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr _: ?m.28473
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.28481} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h': ?m.28045
h'),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr (decr_val evr x) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_val_pos_succ: ∀ {R : Type ?u.28501} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr _: ?m.28502
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.28510} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h'm: SurjVal.v evr.valtn (-x) > ofN 0
h'm),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (decr_val evr (-x)) n = -sub_val evr (decr_val evr x) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_decr_val_comm: ∀ {R : Type ?u.28520} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)
sub_val_decr_val_comm,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrdecr_val evr (sub_val evr (-x) n) = -sub_val evr (decr_val evr x) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)ih: ?m.27896 n
ih,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrdecr_val evr (-sub_val evr x n) = -sub_val evr (decr_val evr x) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)decr_val_neg: ∀ {R : Type ?u.28545} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R),
  decr_val evr (-x) = -decr_val evr x
decr_val_neg,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inr-decr_val evr (sub_val evr x n) = -sub_val evr (decr_val evr x) n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inrsub_val evr (-x) (Nat.succ n) = -sub_val evr x (Nat.succ n)sub_val_decr_val_comm: ∀ {R : Type ?u.28559} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (n : ℕ),
  sub_val evr (decr_val evr x) n = decr_val evr (sub_val evr x n)
sub_val_decr_val_commR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

ih: sub_val evr (-x) n = -sub_val evr x n

h': SurjVal.v evr.valtn x > ofN 0

h'm: SurjVal.v evr.valtn (-x) > ofN 0

succ.inr-decr_val evr (sub_val evr x n) = -decr_val evr (sub_val evr x n)]
Goals accomplished! 🐙

lemma sub_val_add: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n →
    SurjVal.v evr.valtn y ≥ ofN n → sub_val evr (x + y) n = sub_val evr x n + sub_val evr y n
sub_val_add {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.28616} → R → [inst : IntegralDomain R] → Type ?u.28616
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.28631} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.28638} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n)
  (hy: SurjVal.v evr.valtn y ≥ ofN n
hy : evr: EnatValRing p
evr.valtn: {R : Type ?u.28653} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.28657} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) : sub_val: {R : Type ?u.28666} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x + y: R
y) n: ℕ
n = sub_val: {R : Type ?u.28773} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n + sub_val: {R : Type ?u.28780} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y n: ℕ
n := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x + y) n = sub_val evr x n + sub_val evr y napply nzero_mul_left_cancel: ∀ {R : Type ?u.28841} [inst : IntegralDomain R] (a b c : R), a ≠ 0 → a * b = a * c → b = c
nzero_mul_left_cancel (p: R
p ^ n: ℕ
n)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n ≠ 0
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x + y) n = sub_val evr x n + sub_val evr y n.R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n ≠ 0
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)exact pow_nonzero: ∀ {R : Type ?u.28978} [inst : IntegralDomain R] (a : R) (n : ℕ), a ≠ 0 → a ^ n ≠ 0
pow_nonzero p: R
p n: ℕ
n (p_non_zero: ∀ {R : Type ?u.29002} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.29017} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn)
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x + y) n = sub_val evr x n + sub_val evr y n.R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)←factor_p_of_le_val: ∀ {R : Type ?u.29023} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (_: SurjVal.v evr.valtn (x + y) ≥ ofN n
_ : evr: EnatValRing p
evr.valtn: {R : Type ?u.29034} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.29038} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (x: R
x + y: R
y) ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ax + y = p ^ n * (sub_val evr x n + sub_val evr y n)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (x + y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)mul_add: ∀ {R : Type ?u.29116} [inst : Distrib R] (a b c : R), a * (b + c) = a * b + a * c
mul_add,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ax + y = p ^ n * sub_val evr x n + p ^ n * sub_val evr y n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (x + y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)←factor_p_of_le_val: ∀ {R : Type ?u.29207} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr hx: SurjVal.v evr.valtn x ≥ ofN n
hx,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ax + y = x + p ^ n * sub_val evr y n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (x + y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)←factor_p_of_le_val: ∀ {R : Type ?u.29225} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr hy: SurjVal.v evr.valtn y ≥ ofN n
hyR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ax + y = x + y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (x + y) ≥ ofN n]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (x + y) ≥ ofN n
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

ap ^ n * sub_val evr (x + y) n = p ^ n * (sub_val evr x n + sub_val evr y n)exact Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans (le_min: ∀ {α : Type ?u.29248} [inst : LinearOrder α] {a b c : α}, c ≤ a → c ≤ b → c ≤ min a b
le_min hx: SurjVal.v evr.valtn x ≥ ofN n
hx hy: SurjVal.v evr.valtn y ≥ ofN n
hy) (evr: EnatValRing p
evr.valtn: {R : Type ?u.29255} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v_add_ge_min_v: ∀ {R : Type ?u.29259} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a + b) ≥ min (SurjVal.v self a) (SurjVal.v self b)
v_add_ge_min_v x: R
x y: R
y)
Goals accomplished! 🐙

lemma sub_val_sub: ∀ {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n →
    SurjVal.v evr.valtn y ≥ ofN n → sub_val evr (x - y) n = sub_val evr x n - sub_val evr y n
sub_val_sub {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.29284} → R → [inst : IntegralDomain R] → Type ?u.29284
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.29299} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.29306} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n)
  (hy: SurjVal.v evr.valtn y ≥ ofN n
hy : evr: EnatValRing p
evr.valtn: {R : Type ?u.29321} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.29325} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) : sub_val: {R : Type ?u.29334} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x - y: R
y) n: ℕ
n = sub_val: {R : Type ?u.29405} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n - sub_val: {R : Type ?u.29412} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y n: ℕ
n :=
by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nsub_eq_add_neg: ∀ {G : Type ?u.29459} [inst : SubNegMonoid G] (a b : G), a - b = a + -b
sub_eq_add_neg,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x + -y) n = sub_val evr x n - sub_val evr y n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nsub_eq_add_neg: ∀ {G : Type ?u.29555} [inst : SubNegMonoid G] (a b : G), a - b = a + -b
sub_eq_add_neg,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x + -y) n = sub_val evr x n + -sub_val evr y n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nsub_val_add: ∀ {R : Type ?u.29609} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n →
    SurjVal.v evr.valtn y ≥ ofN n → sub_val evr (x + y) n = sub_val evr x n + sub_val evr y n
sub_val_add evr: EnatValRing p
evr hx: SurjVal.v evr.valtn x ≥ ofN n
hx,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr x n + sub_val evr (-y) n = sub_val evr x n + -sub_val evr y n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (-y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nsub_val_neg: ∀ {R : Type ?u.29648} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  sub_val evr (-x) n = -sub_val evr x n
sub_val_negR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr x n + -sub_val evr y n = sub_val evr x n + -sub_val evr y n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (-y) ≥ ofN n]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

SurjVal.v evr.valtn (-y) ≥ ofN n
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x - y) n = sub_val evr x n - sub_val evr y nsimpa
Goals accomplished! 🐙

lemma sub_val_mul_left: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → sub_val evr (x * y) n = sub_val evr x n * y
sub_val_mul_left {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.29977} → R → [inst : IntegralDomain R] → Type ?u.29977
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.29992} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.29999} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) :
  sub_val: {R : Type ?u.30014} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x * y: R
y) n: ℕ
n = sub_val: {R : Type ?u.30117} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n * y: R
y := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x * y) n = sub_val evr x n * yapply nzero_mul_left_cancel: ∀ {R : Type ?u.30176} [inst : IntegralDomain R] (a b c : R), a ≠ 0 → a * b = a * c → b = c
nzero_mul_left_cancel (p: R
p ^ n: ℕ
n)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n ≠ 0
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x * y) n = sub_val evr x n * y.R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n ≠ 0 R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n ≠ 0
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)exact pow_nonzero: ∀ {R : Type ?u.30313} [inst : IntegralDomain R] (a : R) (n : ℕ), a ≠ 0 → a ^ n ≠ 0
pow_nonzero p: R
p n: ℕ
n (p_non_zero: ∀ {R : Type ?u.30337} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.30352} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn)
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x * y) n = sub_val evr x n * y.R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)←factor_p_of_le_val: ∀ {R : Type ?u.30358} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (_: SurjVal.v evr.valtn (x * y) ≥ ofN n
_ : evr: EnatValRing p
evr.valtn: {R : Type ?u.30369} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.30373} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (x: R
x * y: R
y) ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ax * y = p ^ n * (sub_val evr x n * y)
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

SurjVal.v evr.valtn (x * y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)←mul_assoc: ∀ {G : Type ?u.30456} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ax * y = p ^ n * sub_val evr x n * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

SurjVal.v evr.valtn (x * y) ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)←factor_p_of_le_val: ∀ {R : Type ?u.30568} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr hx: SurjVal.v evr.valtn x ≥ ofN n
hxR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ax * y = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

SurjVal.v evr.valtn (x * y) ≥ ofN n]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

SurjVal.v evr.valtn (x * y) ≥ ofN n
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

ap ^ n * sub_val evr (x * y) n = p ^ n * (sub_val evr x n * y)exact Enat.le_trans: ∀ {n m k : ℕ∪∞}, n ≤ m → m ≤ k → n ≤ k
Enat.le_trans hx: SurjVal.v evr.valtn x ≥ ofN n
hx (val_mul_ge_left: ∀ {R : Type ?u.30591} [inst : IntegralDomain R] {p : R} (nav : SurjVal p) (a b : R),
  SurjVal.v nav (a * b) ≥ SurjVal.v nav a
val_mul_ge_left evr: EnatValRing p
evr.valtn: {R : Type ?u.30595} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn x: R
x y: R
y)
Goals accomplished! 🐙

lemma sub_val_mul_right: ∀ {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn y ≥ ofN n → sub_val evr (x * y) n = x * sub_val evr y n
sub_val_mul_right {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.30621} → R → [inst : IntegralDomain R] → Type ?u.30621
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} {n: ℕ
n : ℕ: Type
ℕ} (hy: SurjVal.v evr.valtn y ≥ ofN n
hy : evr: EnatValRing p
evr.valtn: {R : Type ?u.30636} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.30643} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) :
  sub_val: {R : Type ?u.30658} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x * y: R
y) n: ℕ
n = x: R
x * sub_val: {R : Type ?u.30761} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y n: ℕ
n :=
by R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x * y) n = x * sub_val evr y nrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x * y) n = x * sub_val evr y nmul_comm: ∀ {G : Type ?u.30820} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_comm x: R
x y: R
y,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (y * x) n = x * sub_val evr y n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x * y) n = x * sub_val evr y nsub_val_mul_left: ∀ {R : Type ?u.30856} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → sub_val evr (x * y) n = sub_val evr x n * y
sub_val_mul_left evr: EnatValRing p
evr hy: SurjVal.v evr.valtn y ≥ ofN n
hy,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr y n * x = x * sub_val evr y n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

sub_val evr (x * y) n = x * sub_val evr y nmul_comm: ∀ {G : Type ?u.30885} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_commR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n: ℕ

hy: SurjVal.v evr.valtn y ≥ ofN n

x * sub_val evr y n = x * sub_val evr y n]
Goals accomplished! 🐙

lemma sub_val_mul_sub_val: ∀ {p : R} (evr : EnatValRing p) {x y : R} (n m : ℕ),
  SurjVal.v evr.valtn x ≥ ofN n →
    SurjVal.v evr.valtn y ≥ ofN m → sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m)
sub_val_mul_sub_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.30944} → R → [inst : IntegralDomain R] → Type ?u.30944
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} (n: ℕ
n m: ℕ
m : ℕ: Type
ℕ)
  (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.30961} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.30968} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) (hy: SurjVal.v evr.valtn y ≥ ofN m
hy : evr: EnatValRing p
evr.valtn: {R : Type ?u.30983} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.30987} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN m: ℕ
m) :
  sub_val: {R : Type ?u.30999} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n * sub_val: {R : Type ?u.31006} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y m: ℕ
m = sub_val: {R : Type ?u.31013} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x * y: R
y) (n: ℕ
n + m: ℕ
m) := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m)apply nzero_mul_left_cancel: ∀ {R : Type ?u.31207} [inst : IntegralDomain R] (a b c : R), a ≠ 0 → a * b = a * c → b = c
nzero_mul_left_cancel (p: R
p ^ (n: ℕ
n + m: ℕ
m)) _: ?m.31208
_ _: ?m.31208
_ (pow_nonzero: ∀ {R : Type ?u.31355} [inst : IntegralDomain R] (a : R) (n : ℕ), a ≠ 0 → a ^ n ≠ 0
pow_nonzero p: R
p _: ℕ
_ (p_non_zero: ∀ {R : Type ?u.31389} [inst : IntegralDomain R] {p : R}, SurjVal p → ¬p = 0
p_non_zero evr: EnatValRing p
evr.valtn: {R : Type ?u.31398} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn))R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)←factor_p_of_le_val: ∀ {R : Type ?u.31407} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (_: SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
_ : evr: EnatValRing p
evr.valtn: {R : Type ?u.31418} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.31422} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (x: R
x * y: R
y) ≥ ofN: ℕ → ℕ∪∞
ofN (n: ℕ
n + m: ℕ
m)),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)pow_add: ∀ {M : Type ?u.31529} [inst : Monoid M] (a : M) (m n : ℕ), a ^ (m + n) = a ^ m * a ^ n
pow_add,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ n * p ^ m * (sub_val evr x n * sub_val evr y m) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)mul_assoc: ∀ {G : Type ?u.31623} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ n * (p ^ m * (sub_val evr x n * sub_val evr y m)) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)mul_comm: ∀ {G : Type ?u.31723} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_comm (p: R
p ^ m: ℕ
m),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ n * (sub_val evr x n * sub_val evr y m * p ^ m) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)← mul_assoc: ∀ {G : Type ?u.31811} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ n * (sub_val evr x n * sub_val evr y m) * p ^ m = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)← mul_assoc: ∀ {G : Type ?u.31882} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ n * sub_val evr x n * sub_val evr y m * p ^ m = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)←factor_p_of_le_val: ∀ {R : Type ?u.31962} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (_: SurjVal.v evr.valtn x ≥ ofN n
_ : evr: EnatValRing p
evr.valtn: {R : Type ?u.31973} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.31977} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

x * sub_val evr y m * p ^ m = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)mul_assoc: ∀ {G : Type ?u.31987} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

x * (sub_val evr y m * p ^ m) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)mul_comm: ∀ {G : Type ?u.32055} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_comm _: ?m.32056
_ (p: R
p ^ m: ℕ
m),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

x * (p ^ m * sub_val evr y m) = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

p ^ (n + m) * (sub_val evr x n * sub_val evr y m) = p ^ (n + m) * sub_val evr (x * y) (n + m)←factor_p_of_le_val: ∀ {R : Type ?u.32112} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {n : ℕ},
  SurjVal.v evr.valtn x ≥ ofN n → x = p ^ n * sub_val evr x n
factor_p_of_le_val evr: EnatValRing p
evr (_: SurjVal.v evr.valtn y ≥ ofN m
_ : evr: EnatValRing p
evr.valtn: {R : Type ?u.32123} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.32127} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN m: ℕ
m)R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

x * y = x * y
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn y ≥ ofN m
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn y ≥ ofN m
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m).R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn y ≥ ofN m R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn y ≥ ofN m
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)assumption
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m).R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)assumption
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m).R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)SurjVal.v_mul_eq_add_v: ∀ {R : Type ?u.32144} {p : R} [inst : IntegralDomain R] (self : SurjVal p) (a b : R),
  SurjVal.v self (a * b) = SurjVal.v self a + SurjVal.v self b
SurjVal.v_mul_eq_add_v,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x + SurjVal.v evr.valtn y ≥ ofN (n + m) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)← add_ofN: ∀ (a b : ℕ), ofN a + ofN b = ofN (a + b)
add_ofNR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x + SurjVal.v evr.valtn y ≥ ofN n + ofN m]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn x + SurjVal.v evr.valtn y ≥ ofN n + ofN m
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

SurjVal.v evr.valtn (x * y) ≥ ofN (n + m)exact add_le_add: ∀ {a b c d : ℕ∪∞}, a ≤ b → c ≤ d → a + c ≤ b + d
add_le_add hx: SurjVal.v evr.valtn x ≥ ofN n
hx hy: SurjVal.v evr.valtn y ≥ ofN m
hy
Goals accomplished! 🐙

lemma sub_val_mul: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} (n m : ℕ) {nm : ℕ},
  n + m = nm →
    SurjVal.v evr.valtn x ≥ ofN n →
      SurjVal.v evr.valtn y ≥ ofN m → sub_val evr (x * y) nm = sub_val evr x n * sub_val evr y m
sub_val_mul {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.32226} → R → [inst : IntegralDomain R] → Type ?u.32226
EnatValRing p: R
p) {x: R
x y: R
y : R: Type u
R} (n: ℕ
n m: ℕ
m : ℕ: Type
ℕ) {nm: ℕ
nm : ℕ: Type
ℕ} (h: n + m = nm
h : n: ℕ
n + m: ℕ
m = nm: ℕ
nm)
  (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.32289} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.32296} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) (hy: SurjVal.v evr.valtn y ≥ ofN m
hy : evr: EnatValRing p
evr.valtn: {R : Type ?u.32311} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.32315} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y ≥ ofN: ℕ → ℕ∪∞
ofN m: ℕ
m) :
  sub_val: {R : Type ?u.32324} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x * y: R
y) nm: ℕ
nm = sub_val: {R : Type ?u.32427} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n * sub_val: {R : Type ?u.32434} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y m: ℕ
m := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m, nm: ℕ

h: n + m = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr (x * y) nm = sub_val evr x n * sub_val evr y mrw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m, nm: ℕ

h: n + m = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr (x * y) nm = sub_val evr x n * sub_val evr y m← h: n + m = nm
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m, nm: ℕ

h: n + m = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr (x * y) (n + m) = sub_val evr x n * sub_val evr y m R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m, nm: ℕ

h: n + m = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr (x * y) nm = sub_val evr x n * sub_val evr y msub_val_mul_sub_val: ∀ {R : Type ?u.32500} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} (n m : ℕ),
  SurjVal.v evr.valtn x ≥ ofN n →
    SurjVal.v evr.valtn y ≥ ofN m → sub_val evr x n * sub_val evr y m = sub_val evr (x * y) (n + m)
sub_val_mul_sub_val _: EnatValRing ?m.32503
_ _: ℕ
_ _: ℕ
_ hx: SurjVal.v evr.valtn x ≥ ofN n
hx hy: SurjVal.v evr.valtn y ≥ ofN m
hyR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x, y: R

n, m, nm: ℕ

h: n + m = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

hy: SurjVal.v evr.valtn y ≥ ofN m

sub_val evr (x * y) (n + m) = sub_val evr (x * y) (n + m)]
Goals accomplished! 🐙

lemma sub_val_pow: ∀ {p : R} (evr : EnatValRing p) {x : R} (n k : ℕ) {nm : ℕ},
  k * n = nm → SurjVal.v evr.valtn x ≥ ofN n → sub_val evr (x ^ k) nm = sub_val evr x n ^ k
sub_val_pow {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.32563} → R → [inst : IntegralDomain R] → Type ?u.32563
EnatValRing p: R
p) {x: R
x : R: Type u
R} (n: ℕ
n k: ℕ
k : ℕ: Type
ℕ) {nm: ℕ
nm : ℕ: Type
ℕ} (h: k * n = nm
h : k: ℕ
k * n: ℕ
n = nm: ℕ
nm)
  (hx: SurjVal.v evr.valtn x ≥ ofN n
hx : evr: EnatValRing p
evr.valtn: {R : Type ?u.32628} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.32635} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v x: R
x ≥ ofN: ℕ → ℕ∪∞
ofN n: ℕ
n) :
  sub_val: {R : Type ?u.32650} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (x: R
x ^ k: ℕ
k) nm: ℕ
nm = sub_val: {R : Type ?u.32790} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x n: ℕ
n ^ k: ℕ
k := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, k, nm: ℕ

h: k * n = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x ^ k) nm = sub_val evr x n ^ kinduction k: ℕ
k generalizing nm: ℕ
nm with
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, k, nm: ℕ

h: k * n = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x ^ k) nm = sub_val evr x n ^ k| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

nm: ℕ

h: Nat.zero * n = nm

zerosub_val evr (x ^ Nat.zero) nm = sub_val evr x n ^ Nat.zerosimp [← h: Nat.zero * n = nm
h]
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, k, nm: ℕ

h: k * n = nm

hx: SurjVal.v evr.valtn x ≥ ofN n

sub_val evr (x ^ k) nm = sub_val evr x n ^ k| succ: ℕ → ℕ
succ k: ℕ
k ih: ?m.32866 k
ih =>
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ krw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ kpow_succ: ∀ {M : Type ?u.33121} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x * x ^ k) nm = sub_val evr x n ^ Nat.succ k R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ ksub_val_mul: ∀ {R : Type ?u.33179} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x y : R} (n m : ℕ) {nm : ℕ},
  n + m = nm →
    SurjVal.v evr.valtn x ≥ ofN n →
      SurjVal.v evr.valtn y ≥ ofN m → sub_val evr (x * y) nm = sub_val evr x n * sub_val evr y m
sub_val_mul _: EnatValRing ?m.33182
_ n: ℕ
n (k: ℕ
k * n: ℕ
n),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr x n * sub_val evr (x ^ k) (k * n) = sub_val evr x n ^ Nat.succ k
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ kpow_succ: ∀ {M : Type ?u.33233} [inst : Monoid M] (a : M) (n : ℕ), a ^ (n + 1) = a * a ^ n
pow_succ,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr x n * sub_val evr (x ^ k) (k * n) = sub_val evr x n * sub_val evr x n ^ k
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ k← ih: ?m.32866 k
ihR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr x n * sub_val evr (x ^ k) (k * n) = sub_val evr x n * sub_val evr (x ^ k) ?m.33303
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succk * n = ?m.33303
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

ℕ
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succk * n = k * n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ krflR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ krw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)← h: Nat.succ k * n = nm
h,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = Nat.succ k * n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)Nat.succ_mul: ∀ (n m : ℕ), Nat.succ n * m = n * m + m
Nat.succ_mul,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = k * n + n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hn + k * n = nm
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)add_comm: ∀ {G : Type ?u.33327} [inst : AddCommSemigroup G] (a b : G), a + b = b + a
add_commR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hk * n + n = k * n + n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hxSurjVal.v evr.valtn x ≥ ofN n
R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ kexact hx: SurjVal.v evr.valtn x ≥ ofN n
hxR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succ.hySurjVal.v evr.valtn (x ^ k) ≥ ofN (k * n)
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ kconvert val_pow_ge_of_ge: ∀ {R : Type ?u.33405} [inst : IntegralDomain R] {m : ℕ∪∞} {p : R} (nav : SurjVal p) {a : R} (k : ℕ),
  SurjVal.v nav a ≥ m → SurjVal.v nav (a ^ k) ≥ k • m
val_pow_ge_of_ge evr: EnatValRing p
evr.valtn: {R : Type ?u.33410} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn k: ℕ
k hx: SurjVal.v evr.valtn x ≥ ofN n
hxR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

e_bofN (k * n) = k • ofN n
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

hx: SurjVal.v evr.valtn x ≥ ofN n

k: ℕ

ih: ∀ {nm : ℕ}, k * n = nm → sub_val evr (x ^ k) nm = sub_val evr x n ^ k

nm: ℕ

h: Nat.succ k * n = nm

succsub_val evr (x ^ Nat.succ k) nm = sub_val evr x n ^ Nat.succ kexact Enat.ofN_mul_eq_smul: ∀ (a b : ℕ), ofN (a * b) = a • ofN b
Enat.ofN_mul_eq_smul _: ℕ
_ _: ℕ
_
Goals accomplished! 🐙

lemma sub_val_sub_val: ∀ {R : Type u} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) {x : R} {m n : ℕ},
  sub_val evr (sub_val evr x m) n = sub_val evr x (m + n)
sub_val_sub_val {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.33685} → R → [inst : IntegralDomain R] → Type ?u.33685
EnatValRing p: R
p) {x: R
x : R: Type u
R} {m: ℕ
m n: ℕ
n : ℕ: Type
ℕ} : sub_val: {R : Type ?u.33700} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (sub_val: {R : Type ?u.33710} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x m: ℕ
m) n: ℕ
n = sub_val: {R : Type ?u.33714} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr x: R
x (m: ℕ
m + n: ℕ
n) := by
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

sub_val evr (sub_val evr x m) n = sub_val evr x (m + n)have general: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)
general : ∀ y: R
y : R: Type u
R, sub_val: {R : Type ?u.33775} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr (sub_val: {R : Type ?u.33782} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y m: ℕ
m) n: ℕ
n = sub_val: {R : Type ?u.33786} → [inst : IntegralDomain R] → {p : R} → EnatValRing p → R → ℕ → R
sub_val evr: EnatValRing p
evr y: R
y (m: ℕ
m + n: ℕ
n) := R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

sub_val evr (sub_val evr x m) n = sub_val evr x (m + n)by
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)induction m: ℕ
m with
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n: ℕ

zero∀ (y : R), sub_val evr (sub_val evr y Nat.zero) n = sub_val evr y (Nat.zero + n)simp [sub_val_x_zero: ∀ {R : Type ?u.33841} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R), sub_val evr x 0 = x
sub_val_x_zero]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)| succ: ℕ → ℕ
succ m: ℕ
m ih: ?m.33834 m
ih =>
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

succ∀ (y : R), sub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)intro y: R
yR: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

succsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

succ∀ (y : R), sub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)cases eq_zero_or_pos: ∀ (n : ℕ∪∞), n = ofN 0 ∨ n > ofN 0
eq_zero_or_pos (evr: EnatValRing p
evr.valtn: {R : Type ?u.34168} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.34172} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v y: R
y) with
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

x✝: SurjVal.v evr.valtn y = ofN 0 ∨ SurjVal.v evr.valtn y > ofN 0

succsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)| inl: ∀ {a b : Prop}, a → a ∨ b
inl h': ?m.34200
h' => R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y = ofN 0

succ.inlsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)simp [sub_val_val_zero: ∀ {R : Type ?u.34231} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x = 0 → sub_val evr x m = x
sub_val_val_zero evr: EnatValRing p
evr y: R
y _: ℕ
_ h': ?m.34200
h']
Goals accomplished! 🐙
      R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

x✝: SurjVal.v evr.valtn y = ofN 0 ∨ SurjVal.v evr.valtn y > ofN 0

succsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)| inr: ∀ {a b : Prop}, b → a ∨ b
inr h': ?m.34201
h' =>
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)rw [R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)sub_val_val_pos_succ: ∀ {R : Type ?u.34276} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr y: R
y m: ℕ
m (ne_of_gt: ∀ {α : Type ?u.34283} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h': ?m.34201
h'),R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr (decr_val evr y) m) n = sub_val evr y (Nat.succ m + n) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)Nat.succ_add: ∀ (n m : ℕ), Nat.succ n + m = Nat.succ (n + m)
Nat.succ_add,R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr (decr_val evr y) m) n = sub_val evr y (Nat.succ (m + n)) R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)sub_val_val_pos_succ: ∀ {R : Type ?u.34312} [inst : IntegralDomain R] {p : R} (evr : EnatValRing p) (x : R) (m : ℕ),
  SurjVal.v evr.valtn x ≠ 0 → sub_val evr x (Nat.succ m) = sub_val evr (decr_val evr x) m
sub_val_val_pos_succ evr: EnatValRing p
evr y: R
y _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.34320} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h': ?m.34201
h')R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr (decr_val evr y) m) n = sub_val evr (decr_val evr y) (m + n)]R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr (decr_val evr y) m) n = sub_val evr (decr_val evr y) (m + n)
        R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

n, m: ℕ

ih: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)

y: R

h': SurjVal.v evr.valtn y > ofN 0

succ.inrsub_val evr (sub_val evr y (Nat.succ m)) n = sub_val evr y (Nat.succ m + n)exact ih: ?m.33834 m
ih (evr: EnatValRing p
evr.decr_val: {R : Type ?u.34334} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → R → R
decr_val y: R
y)
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: R

evr: EnatValRing p

x: R

m, n: ℕ

sub_val evr (sub_val evr x m) n = sub_val evr x (m + n)exact general: ∀ (y : R), sub_val evr (sub_val evr y m) n = sub_val evr y (m + n)
general x: R
x
Goals accomplished! 🐙

def has_double_root: {p : R} → (evr : EnatValRing p) → (a b c : R) → ?m.34400 evr a b c
has_double_root {p: R
p : R: Type u
R} (evr: EnatValRing p
evr : EnatValRing: {R : Type ?u.34385} → R → [inst : IntegralDomain R] → Type ?u.34385
EnatValRing p: R
p) (a: R
a b: R
b c: R
c : R: Type u
R) :=
  evr: EnatValRing p
evr.valtn: {R : Type ?u.34421} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.34425} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v a: R
a = 0: ?m.34433
0 ∧ evr: EnatValRing p
evr.valtn: {R : Type ?u.34663} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.34667} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v (b: R
b ^ 2: ?m.34678
2 - 4: ?m.34694
4 * a: R
a * c: R
c) > 0: ?m.35007
0

end EnatValRing


def nat_prime: ℕ → Prop
nat_prime (p: ℕ
p : ℕ: Type
ℕ) : Prop: Type
Prop := 1: ?m.35302
1 < p: ℕ
p ∧ (∀ a: ℕ
a b: ℕ
b : ℕ: Type
ℕ, (a: ℕ
a * b: ℕ
b) % p: ℕ
p = 0: ?m.35349
0 → a: ℕ
a % p: ℕ
p = 0: ?m.35447
0 ∨ b: ℕ
b % p: ℕ
p = 0: ?m.35486
0)

lemma ndiv_mul_left: ∀ (a b p : ℕ), a * b % p ≠ 0 → a % p ≠ 0
ndiv_mul_left (a: ℕ
a b: ℕ
b p: ℕ
p : ℕ: Type
ℕ) : (a: ℕ
a * b: ℕ
b) % p: ℕ
p ≠ 0: ?m.35625
0 → a: ℕ
a % p: ℕ
p ≠ 0: ?m.35660
0 := by
  R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → a % p ≠ 0intro hab: a * b % p ≠ 0
hab ha: a % p = 0
haR: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

hab: a * b % p ≠ 0

ha: a % p = 0

False
  R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → a % p ≠ 0apply hab: a * b % p ≠ 0
habR: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

hab: a * b % p ≠ 0

ha: a % p = 0

a * b % p = 0
  R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → a % p ≠ 0simp [Nat.mul_mod: ∀ (a b n : ℕ), a * b % n = a % n * (b % n) % n
Nat.mul_mod, ha: a % p = 0
ha]
Goals accomplished! 🐙

lemma ndiv_mul_right: ∀ (a b p : ℕ), a * b % p ≠ 0 → b % p ≠ 0
ndiv_mul_right (a: ℕ
a b: ℕ
b p: ℕ
p : ℕ: Type
ℕ) : (a: ℕ
a * b: ℕ
b) % p: ℕ
p ≠ 0: ?m.35924
0 → b: ℕ
b % p: ℕ
p ≠ 0: ?m.35959
0 := by
  R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → b % p ≠ 0rw [R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → b % p ≠ 0Nat.mul_comm: ∀ (n m : ℕ), n * m = m * n
Nat.mul_commR: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

b * a % p ≠ 0 → b % p ≠ 0]R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

b * a % p ≠ 0 → b % p ≠ 0
  R: Type u

inst✝: IntegralDomain R

a, b, p: ℕ

a * b % p ≠ 0 → b % p ≠ 0exact ndiv_mul_left: ∀ (a b p : ℕ), a * b % p ≠ 0 → a % p ≠ 0
ndiv_mul_left b: ℕ
b a: ℕ
a p: ℕ
p
Goals accomplished! 🐙

lemma nat_prime_test: ∀ (p : ℕ), nat_prime p ↔ 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
nat_prime_test (p: ℕ
p : ℕ: Type
ℕ) : nat_prime: ℕ → Prop
nat_prime p: ℕ
p ↔ (1: ?m.36012
1 < p: ℕ
p ∧ (∀ a: ℕ
a b: ℕ
b : ℕ: Type
ℕ, a: ℕ
a < p: ℕ
p → b: ℕ
b < p: ℕ
p → (a: ℕ
a * b: ℕ
b) % p: ℕ
p = 0: ?m.36069
0 → a: ℕ
a % p: ℕ
p = 0: ?m.36167
0 ∨ b: ℕ
b % p: ℕ
p = 0: ?m.36206
0)) := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

nat_prime p ↔ 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0apply Iff.intro: ∀ {a b : Prop}, (a → b) → (b → a) → (a ↔ b)
Iff.introR: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime p
  R: Type u

inst✝: IntegralDomain R

p: ℕ

nat_prime p ↔ 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0.R: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0 R: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime pintro H: ?a
HR: Type u

inst✝: IntegralDomain R

p: ℕ

H: nat_prime p

mp1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime papply And.intro: ∀ {a b : Prop}, a → b → a ∧ b
And.intro (H: ?a
H.left: ∀ {a b : Prop}, a ∧ b → a
left)R: Type u

inst✝: IntegralDomain R

p: ℕ

H: nat_prime p

mp∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime pintro a: ℕ
a b: ℕ
b _: a < p
_ _: b < p
_R: Type u

inst✝: IntegralDomain R

p: ℕ

H: nat_prime p

a, b: ℕ

a✝¹: a < p

a✝: b < p

mpa * b % p = 0 → a % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpnat_prime p → 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0
R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime papply H: ?a
H.right: ∀ {a b : Prop}, a ∧ b → b
right a: ℕ
a b: ℕ
b
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: ℕ

nat_prime p ↔ 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0.R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime p R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime pintro H: ?b
HR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

mprnat_prime p
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime papply And.intro: ∀ {a b : Prop}, a → b → a ∧ b
And.intro (H: ?b
H.left: ∀ {a b : Prop}, a ∧ b → a
left)R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

mpr∀ (a b : ℕ), a * b % p = 0 → a % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime pintro a: ℕ
a b: ℕ
b p_div_ab: a * b % p = 0
p_div_abR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a * b % p = 0

mpra % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime prw [R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a * b % p = 0

mpra % p = 0 ∨ b % p = 0Nat.mul_mod: ∀ (a b n : ℕ), a * b % n = a % n * (b % n) % n
Nat.mul_modR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

mpra % p = 0 ∨ b % p = 0]R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

mpra % p = 0 ∨ b % p = 0 at p_div_ab: a * b % p = 0
p_div_abR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

mpra % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime phave p_pos: p > 0
p_pos : p: ℕ
p > 0: ?m.36353
0 := lt_trans: ∀ {α : Type ?u.36370} [inst : Preorder α] {a b c : α}, a < b → b < c → a < c
lt_trans Nat.zero_lt_one: 0 < 1
Nat.zero_lt_one H: ?b
H.left: ∀ {a b : Prop}, a ∧ b → a
leftR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

mpra % p = 0 ∨ b % p = 0;R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

mpra % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime phave h: ?m.36399
h := H: ?b
H.right: ∀ {a b : Prop}, a ∧ b → b
right (a: ℕ
a % p: ℕ
p) (b: ℕ
b % p: ℕ
p) (Nat.mod_lt: ∀ (x : ℕ) {y : ℕ}, y > 0 → x % y < y
Nat.mod_lt a: ℕ
a p_pos: p > 0
p_pos) (Nat.mod_lt: ∀ (x : ℕ) {y : ℕ}, y > 0 → x % y < y
Nat.mod_lt b: ℕ
b p_pos: p > 0
p_pos) p_div_ab: a % p * (b % p) % p = 0
p_div_abR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p % p = 0 ∨ b % p % p = 0

mpra % p = 0 ∨ b % p = 0;R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p % p = 0 ∨ b % p % p = 0

mpra % p = 0 ∨ b % p = 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

mpr(1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0) → nat_prime prwa [R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p % p = 0 ∨ b % p % p = 0

mpra % p = 0 ∨ b % p = 0Nat.mod_mod: ∀ (a n : ℕ), a % n % n = a % n
Nat.mod_mod _: ℕ
_ p: ℕ
p,R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p = 0 ∨ b % p % p = 0

mpra % p = 0 ∨ b % p = 0 R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p % p = 0 ∨ b % p % p = 0

mpra % p = 0 ∨ b % p = 0Nat.mod_mod: ∀ (a n : ℕ), a % n % n = a % n
Nat.mod_mod _: ℕ
_ p: ℕ
pR: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p = 0 ∨ b % p = 0

mpra % p = 0 ∨ b % p = 0]R: Type u

inst✝: IntegralDomain R

p: ℕ

H: 1 < p ∧ ∀ (a b : ℕ), a < p → b < p → a * b % p = 0 → a % p = 0 ∨ b % p = 0

a, b: ℕ

p_div_ab: a % p * (b % p) % p = 0

p_pos: p > 0

h: a % p = 0 ∨ b % p = 0

mpra % p = 0 ∨ b % p = 0 at h: ?m.36399
h
Goals accomplished! 🐙



instance: DecidablePred fun x => nat_prime x
instanceWarning: declaration uses 'sorry' : DecidablePred: {α : Sort ?u.36532} → (α → Prop) → Sort (max 1 ?u.36532)
DecidablePred (nat_prime: ℕ → Prop
nat_prime . : ℕ: Type
ℕ → Prop: Type
Prop) := fun p: ?m.36546
p => sorry: ?m.36549
sorry
--match p with
  --| 0 => sorry --isFalse (not_and_of_not_left _ (not_lt_of_ge (le_of_lt Nat.zero_lt_one)))
  --| 1 => isFalse (not_and_of_not_left _ (not_lt_of_ge (le_of_eq rfl)))
  --| Nat.succ (Nat.succ p') => sorry



--def fmul_eq_addf {R R' : Type u} [Mul R] [Add R'] (f : R → R') (x y : R) : Prop := f (x * y) = f x + f y



namespace Int


def nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation : ℕ: Type
ℕ → ℕ: Type
ℕ → ℕ∪∞: Type
ℕ∪∞
  | _, 0: ℕ
0 => ∞: ℕ∪∞
∞
  | 0: ℕ
0, (_: ℕ
_+1) => ofN: ℕ → ℕ∪∞
ofN 0: ?m.36700
0
  | 1: ℕ
1, (_: ℕ
_+1) => ∞: ℕ∪∞
∞
  | (q: ℕ
q+2), (m: ℕ
m+1) => if (m: ℕ
m+1: ?m.36881
1) % (q: ℕ
q+2: ?m.36895
2) ≠ 0: ?m.36987
0 then ofN: ℕ → ℕ∪∞
ofN 0: ?m.36994
0 else succ: ℕ∪∞ → ℕ∪∞
succ (nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation (q: ℕ
q+2: ?m.37000
2) ((m: ℕ
m+1: ?m.37045
1) / (q: ℕ
q+2: ?m.37059
2)))
termination_by nat_valuation p k => k: ℕ
k
decreasing_by
  simp [WellFoundedRelation.rel: {α : Sort ?u.37571} → [self : WellFoundedRelation α] → α → α → Prop
WellFoundedRelation.rel, measure: {α : Sort ?u.37573} → (α → ℕ) → WellFoundedRelation α
measure, invImage: {α : Sort ?u.37576} → {β : Sort ?u.37575} → (α → β) → WellFoundedRelation β → WellFoundedRelation α
invImage, InvImage: {α : Sort ?u.37579} → {β : Sort ?u.37578} → (β → β → Prop) → (α → β) → α → α → Prop
InvImage, Nat.lt_wfRel: WellFoundedRelation ℕ
Nat.lt_wfRel]q, m: ℕ

h✝: ¬(m + 1) % (q + 2) ≠ 0

(m + 1) / (q + 2) < Nat.succ m
  q, m: ℕ

h✝: ¬(m + 1) % (q + 2) ≠ 0

(invImage (fun a => PSigma.casesOn a fun p snd => snd) instWellFoundedRelation).1
  { fst := q + 2, snd := (m + 1) / (q + 2) } { fst := Nat.succ (Nat.succ q), snd := Nat.succ m }exact Nat.div_lt_self: ∀ {n k : ℕ}, 0 < n → 1 < k → n / k < n
Nat.div_lt_self (Nat.zero_lt_succ: ∀ (n : ℕ), 0 < Nat.succ n
Nat.zero_lt_succ m: ℕ
m) (Nat.succ_lt_succ: ∀ {n m : ℕ}, n < m → Nat.succ n < Nat.succ m
Nat.succ_lt_succ (Nat.zero_lt_succ: ∀ (n : ℕ), 0 < Nat.succ n
Nat.zero_lt_succ q: ℕ
q))
Goals accomplished! 🐙

lemma nat_val_zero: ∀ (p : ℕ), nat_valuation p 0 = ∞
nat_val_zero (p: ℕ
p : ℕ: Type
ℕ) : nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p 0: ?m.38639
0 = ∞: ℕ∪∞
∞ := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

nat_valuation p 0 = ∞simp [nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation]
Goals accomplished! 🐙
lemma nat_val_succ: ∀ (q m : ℕ),
  nat_valuation (q + 2) (m + 1) =     if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))
nat_val_succ (q: ℕ
q m: ℕ
m : ℕ: Type
ℕ) : nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation (q: ℕ
q+2: ?m.51833
2) (m: ℕ
m+1: ?m.51887
1) = if (m: ℕ
m+1: ?m.51948
1) % (q: ℕ
q+2: ?m.51962
2) ≠ 0: ?m.52054
0 then ofN: ℕ → ℕ∪∞
ofN 0: ?m.52065
0 else succ: ℕ∪∞ → ℕ∪∞
succ (nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation (q: ℕ
q+2: ?m.52071
2) ((m: ℕ
m+1: ?m.52116
1) / (q: ℕ
q+2: ?m.52130
2))) := by R: Type u

inst✝: IntegralDomain R

q, m: ℕ

nat_valuation (q + 2) (m + 1) =   if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))rfl
Goals accomplished! 🐙


def int_val: ℕ → ℤ → ℕ∪∞
int_val (p: ℕ
p : ℕ: Type
ℕ) (k: ℤ
k : ℤ: Type
ℤ) : ℕ∪∞: Type
ℕ∪∞ :=
  nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p (natAbs: ℤ → ℕ
natAbs k: ℤ
k)

lemma int_val_uniformizer: ∀ {p : ℕ}, 1 < p → int_val p ↑p = ofN 1
int_val_uniformizer {p: ℕ
p : ℕ: Type
ℕ} (gt1: 1 < p
gt1 : 1: ?m.55151
1 < p: ℕ
p) : int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p p: ℕ
p = ofN: ℕ → ℕ∪∞
ofN 1: ?m.55273
1 := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

int_val p ↑p = ofN 1simp only [natAbs_cast: ∀ (n : ℕ), natAbs ↑n = n
natAbs_cast, int_val: ℕ → ℤ → ℕ∪∞
int_val]R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1
  R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

int_val p ↑p = ofN 1match p: ℕ
p with
  R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1| 0: ℕ
0 =>R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < 0

nat_valuation 0 0 = ofN 1
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1apply False.elim: ∀ {C : Sort ?u.55665}, False → C
False.elimR: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < 0

hFalse
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < 0

nat_valuation 0 0 = ofN 1apply Nat.not_lt_zero: ∀ (n : ℕ), ¬n < 0
Nat.not_lt_zero 1: ?m.55671
1R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < 0

h1 < 0
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < 0

nat_valuation 0 0 = ofN 1assumption
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1| Nat.succ: ℕ → ℕ
Nat.succ 0: ℕ
0 =>R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < Nat.succ 0

nat_valuation (Nat.succ 0) (Nat.succ 0) = ofN 1
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1apply False.elim: ∀ {C : Sort ?u.55684}, False → C
False.elimR: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < Nat.succ 0

hFalse
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < Nat.succ 0

nat_valuation (Nat.succ 0) (Nat.succ 0) = ofN 1apply Nat.lt_irrefl: ∀ (n : ℕ), ¬n < n
Nat.lt_irrefl 1: ?m.55690
1R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < Nat.succ 0

h1 < 1
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < Nat.succ 0

nat_valuation (Nat.succ 0) (Nat.succ 0) = ofN 1assumption
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1| q: ℕ
q+2 =>R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1
    R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

nat_valuation p p = ofN 1rw [R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1nat_val_succ: ∀ (q m : ℕ),
  nat_valuation (q + 2) (m + 1) =     if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))
nat_val_succ,R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

(if (q + 1 + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2)))) = ofN 1 R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1Nat.mod_self: ∀ (n : ℕ), n % n = 0
Nat.mod_self,R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

(if 0 ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2)))) = ofN 1 R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1if_neg: ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort ?u.55734} {t e : α}, (if c then t else e) = e
if_neg _: ¬?m.55735
_R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0]R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1rw [R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0Nat.div_self: ∀ {n : ℕ}, 0 < n → n / n = 1
Nat.div_self,R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) 1) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0 R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0nat_val_succ: ∀ (q m : ℕ),
  nat_valuation (q + 2) (m + 1) =     if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))
nat_val_succ,R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (if (0 + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((0 + 1) / (q + 2)))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0 R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0if_pos: ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort ?u.55773} {t e : α}, (if c then t else e) = t
if_pos,R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (ofN 0) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc(0 + 1) % (q + 2) ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0 R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

succ (nat_valuation (q + 2) ((q + 1 + 1) / (q + 2))) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0succ_ofN: ∀ (a : ℕ), succ (ofN a) = ofN (Nat.succ a)
succ_ofNR: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

ofN (Nat.succ 0) = ofN 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc(0 + 1) % (q + 2) ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0]R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc(0 + 1) % (q + 2) ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1rw [R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc(0 + 1) % (q + 2) ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0Nat.mod_eq_of_lt: ∀ {a b : ℕ}, a < b → a % b = a
Nat.mod_eq_of_ltR: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc0 + 1 ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc0 + 1 < q + 2
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0]R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc0 + 1 ≠ 0
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc0 + 1 < q + 2
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1exact Nat.succ_ne_zero: ∀ (n : ℕ), Nat.succ n ≠ 0
Nat.succ_ne_zero 0: ?m.55820
0R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

hc0 + 1 < q + 2
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1assumptionR: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

0 < q + 1 + 1
R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1exact lt_trans: ∀ {α : Type ?u.55830} [inst : Preorder α] {a b c : α}, a < b → b < c → a < c
lt_trans (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.55853
0) gt1: 1 < q + 2
gt1R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

¬0 ≠ 0
    R: Type u

inst✝: IntegralDomain R

p, q: ℕ

gt1: 1 < q + 2

nat_valuation (q + 2) (q + 2) = ofN 1exact Ne.irrefl: ∀ {α : Sort ?u.55855} {a : α}, a ≠ a → False
Ne.irrefl
Goals accomplished! 🐙

lemma nat_val_mul_eq_add: ∀ (p : ℕ), nat_prime p → ∀ (a b : ℕ), nat_valuation p (a * b) = nat_valuation p a + nat_valuation p b
nat_val_mul_eq_add (p: ℕ
p : ℕ: Type
ℕ) (prime: nat_prime p
prime : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) (a: ℕ
a b: ℕ
b : ℕ: Type
ℕ) : nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p (a: ℕ
a * b: ℕ
b) = nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p a: ℕ
a + nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p b: ℕ
b := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

nat_valuation p (a * b) = nat_valuation p a + nat_valuation p bhave general: ∀ (n c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d
general (n: ℕ
n : ℕ: Type
ℕ) : ∀ c: ?m.55987
c d: ?m.55990
d, c: ?m.55987
c + d: ?m.55990
d ≤ n: ℕ
n → nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p (c: ?m.55987
c * d: ?m.55990
d) = nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p c: ?m.55987
c + nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p d: ?m.55990
d := R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

nat_valuation p (a * b) = nat_valuation p a + nat_valuation p bby
    R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p dinduction n: ℕ
n with
    R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d| zero: ℕ
zero =>
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

zero∀ (c d : ℕ), c + d ≤ Nat.zero → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p dintro c: ℕ
c d: ℕ
d h_sum: c + d ≤ Nat.zero
h_sumR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (c * d) = nat_valuation p c + nat_valuation p d
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

zero∀ (c d : ℕ), c + d ≤ Nat.zero → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p drw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (c * d) = nat_valuation p c + nat_valuation p dNat.eq_zero_of_add_eq_zero_right: ∀ {n m : ℕ}, n + m = 0 → n = 0
Nat.eq_zero_of_add_eq_zero_right (Nat.eq_zero_of_le_zero: ∀ {n : ℕ}, n ≤ 0 → n = 0
Nat.eq_zero_of_le_zero h_sum: c + d ≤ Nat.zero
h_sum),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (0 * d) = nat_valuation p 0 + nat_valuation p d R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (c * d) = nat_valuation p c + nat_valuation p dNat.eq_zero_of_add_eq_zero_left: ∀ {n m : ℕ}, n + m = 0 → m = 0
Nat.eq_zero_of_add_eq_zero_left (Nat.eq_zero_of_le_zero: ∀ {n : ℕ}, n ≤ 0 → n = 0
Nat.eq_zero_of_le_zero h_sum: c + d ≤ Nat.zero
h_sum)R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (0 * 0) = nat_valuation p 0 + nat_valuation p 0]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, c, d: ℕ

h_sum: c + d ≤ Nat.zero

zeronat_valuation p (0 * 0) = nat_valuation p 0 + nat_valuation p 0
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

zero∀ (c d : ℕ), c + d ≤ Nat.zero → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p dsimp [nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation]
Goals accomplished! 🐙
    R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d| succ: ℕ → ℕ
succ n: ℕ
n ih: ?m.56102 n
ih =>
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

succ∀ (c d : ℕ), c + d ≤ Nat.succ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p dintro c: ℕ
c d: ℕ
d h_sum: c + d ≤ Nat.succ n
h_sumR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: c + d ≤ Nat.succ n

succnat_valuation p (c * d) = nat_valuation p c + nat_valuation p d
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

succ∀ (c d : ℕ), c + d ≤ Nat.succ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p dcases c: ℕ
c with
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: c + d ≤ Nat.succ n

succnat_valuation p (c * d) = nat_valuation p c + nat_valuation p d| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

d: ℕ

h_sum: Nat.zero + d ≤ Nat.succ n

succ.zeronat_valuation p (Nat.zero * d) = nat_valuation p Nat.zero + nat_valuation p dsimp [nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation]
Goals accomplished! 🐙
      R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: c + d ≤ Nat.succ n

succnat_valuation p (c * d) = nat_valuation p c + nat_valuation p d| succ: ℕ → ℕ
succ c: ℕ
c => R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

d, c: ℕ

h_sum: Nat.succ c + d ≤ Nat.succ n

succ.succnat_valuation p (Nat.succ c * d) = nat_valuation p (Nat.succ c) + nat_valuation p dcases d: ℕ
d with
        R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

d, c: ℕ

h_sum: Nat.succ c + d ≤ Nat.succ n

succ.succnat_valuation p (Nat.succ c * d) = nat_valuation p (Nat.succ c) + nat_valuation p d| zero: ℕ
zero => R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c: ℕ

h_sum: Nat.succ c + Nat.zero ≤ Nat.succ n

succ.succ.zeronat_valuation p (Nat.succ c * Nat.zero) = nat_valuation p (Nat.succ c) + nat_valuation p Nat.zerosimp [nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation]
Goals accomplished! 🐙
        R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

d, c: ℕ

h_sum: Nat.succ c + d ≤ Nat.succ n

succ.succnat_valuation p (Nat.succ c * d) = nat_valuation p (Nat.succ c) + nat_valuation p d| succ: ℕ → ℕ
succ d: ℕ
d =>
          R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

succ.succ.succnat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)match Nat.le.dest: ∀ {n m : ℕ}, n ≤ m → ∃ k, n + k = m
Nat.le.dest (Nat.succ_le_of_lt: ∀ {n m : ℕ}, n < m → Nat.succ n ≤ m
Nat.succ_le_of_lt prime: nat_prime p
prime.left: ∀ {a b : Prop}, a ∧ b → a
left) with
          R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

succ.succ.succnat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)| ⟨q: ℕ
q, hq: Nat.succ 1 + q = p
hq⟩ =>R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

succ.succ.succnat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)(show Nat.succ: ℕ → ℕ
Nat.succ 1: ?m.56603
1 = 2: ?m.56614
2 by R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)rfl
Goals accomplished! 🐙),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: 2 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)Nat.add_comm: ∀ (n m : ℕ), n + m = m + n
Nat.add_commR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d) at hq: 2 + q = p
hqR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)simp only [←hq: q + 2 = p
hq, (show c: ℕ
c.succ: ℕ → ℕ
succ * d: ℕ
d.succ: ℕ → ℕ
succ = (c: ℕ
c * d: ℕ
d + c: ℕ
c + d: ℕ
d).succ: ℕ → ℕ
succ by R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)simp [Nat.succ_mul: ∀ (n m : ℕ), Nat.succ n * m = n * m + m
Nat.succ_mul, Nat.mul_succ: ∀ (n m : ℕ), n * Nat.succ m = n * m + n
Nat.mul_succ, Nat.add_succ: ∀ (n m : ℕ), n + Nat.succ m = Nat.succ (n + m)
Nat.add_succ]
Goals accomplished! 🐙), nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

(if (c * d + c + d + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((c * d + c + d + 1) / (q + 2)))) =   (if (c + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((c + 1) / (q + 2)))) +     if (d + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((d + 1) / (q + 2)))
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)simp only [hq: q + 2 = p
hq, (show c: ℕ
c * d: ℕ
d + c: ℕ
c + d: ℕ
d + 1: ?m.57342
1 = (c: ℕ
c + 1: ?m.57364
1) * (d: ℕ
d + 1: ?m.57378
1) by R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

(if (c * d + c + d + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((c * d + c + d + 1) / (q + 2)))) =   (if (c + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((c + 1) / (q + 2)))) +     if (d + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((d + 1) / (q + 2)))ring
Goals accomplished! 🐙)]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: Nat.succ 1 + q = p

nat_valuation p (Nat.succ c * Nat.succ d) = nat_valuation p (Nat.succ c) + nat_valuation p (Nat.succ d)cases Nat.eq_zero_or_pos: ∀ (n : ℕ), n = 0 ∨ n > 0
Nat.eq_zero_or_pos ((c: ℕ
c + 1: ?m.58087
1) * (d: ℕ
d + 1: ?m.58101
1) % p: ℕ
p) with
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

x✝: (c + 1) * (d + 1) % p = 0 ∨ (c + 1) * (d + 1) % p > 0

(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))| inl: ∀ {a b : Prop}, a → a ∨ b
inl h: ?m.58273
h =>
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

inl(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

inl(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_neg: ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort ?u.58303} {t e : α}, (if c then t else e) = e
if_neg (not_not_intro: ∀ {p : Prop}, p → ¬¬p
not_not_intro h: ?m.58273
h)R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

inl(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))cases prime: nat_prime p
prime.2: ∀ {a b : Prop}, a ∧ b → b
2 (c: ℕ
c+1: ?m.58347
1) (d: ℕ
d+1: ?m.58387
1) h: ?m.58273
h with
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

x✝: (c + 1) % p = 0 ∨ (d + 1) % p = 0

inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))| inl: ∀ {a b : Prop}, a → a ∨ b
inl h': ?m.58468
h' =>
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_neg: ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort ?u.58498} {t e : α}, (if c then t else e) = e
if_neg (not_not_intro: ∀ {p : Prop}, p → ¬¬p
not_not_intro h': ?m.58468
h'),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   succ (nat_valuation p ((c + 1) / p)) + if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))←hq: q + 2 = p
hq,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation (q + 2) ((c + 1) * (d + 1) / (q + 2))) =   succ (nat_valuation (q + 2) ((c + 1) / (q + 2))) +     if (d + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((d + 1) / (q + 2))) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))←nat_val_succ: ∀ (q m : ℕ),
  nat_valuation (q + 2) (m + 1) =     if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))
nat_val_succ q: ℕ
q d: ℕ
d,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation (q + 2) ((c + 1) * (d + 1) / (q + 2))) =   succ (nat_valuation (q + 2) ((c + 1) / (q + 2))) + nat_valuation (q + 2) (d + 1) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))hq: q + 2 = p
hq,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p)) + nat_valuation p (d + 1) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))succ_add: ∀ (a b : ℕ∪∞), succ a + b = succ (a + b)
succ_addR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p) + nat_valuation p (d + 1))]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p) + nat_valuation p (d + 1))
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have sum_le_n: (c + 1) / p + (d + 1) ≤ n
sum_le_n : (c: ℕ
c + 1: ?m.58546
1) / p: ℕ
p + (d: ℕ
d + 1: ?m.58560
1) ≤ n: ℕ
n := R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p) + nat_valuation p (d + 1))by
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ napply Nat.le_of_lt_succ: ∀ {m n : ℕ}, m < Nat.succ n → m ≤ n
Nat.le_of_lt_succR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

a(c + 1) / p + (d + 1) < Nat.succ n
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ napply lt_of_lt_of_le: ∀ {α : Type ?u.58705} [inst : Preorder α] {a b c : α}, a < b → b ≤ c → a < c
lt_of_lt_of_le _: ?m.58708 < ?m.58709
_ h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n
h_sumR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) < Nat.succ c + Nat.succ d
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ napply Nat.add_lt_add_right: ∀ {n m : ℕ}, n < m → ∀ (k : ℕ), n + k < m + k
Nat.add_lt_add_rightR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

h(c + 1) / p < Nat.succ c
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ napply Nat.div_lt_self: ∀ {n k : ℕ}, 0 < n → 1 < k → n / k < n
Nat.div_lt_self _: 0 < ?m.58740
_ prime: nat_prime p
prime.1: ∀ {a b : Prop}, a ∧ b → a
1R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

0 < c + 1
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ nrw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

0 < c + 1Nat.add_comm: ∀ (n m : ℕ), n + m = m + n
Nat.add_commR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

0 < 1 + c]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

0 < 1 + c
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

(c + 1) / p + (d + 1) ≤ napply Nat.lt_add_right: ∀ (a b c : ℕ), a < b → a < b + c
Nat.lt_add_right 0: ?m.58763
0 1: ?m.58770
1 c: ℕ
c (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.58773
0)
Goals accomplished! 🐙
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p) + nat_valuation p (d + 1))←ih: ?m.56102 n
ih ((c: ℕ
c + 1: ?m.58785
1) / p: ℕ
p) (d: ℕ
d + 1: ?m.58844
1) sum_le_n: (c + 1) / p + (d + 1) ≤ n
sum_le_nR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p * (d + 1)))]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p * (d + 1)))
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)
mul_div_assoc : (c: ℕ
c + 1: ?m.58904
1) * (d: ℕ
d + 1: ?m.58918
1) / p: ℕ
p = (c: ℕ
c + 1: ?m.58948
1) / p: ℕ
p * (d: ℕ
d + 1: ?m.58962
1) := R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p * (d + 1)))by
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

(c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)apply nat_mul_left_cancel: ∀ (a b c : ℕ), a ≠ 0 → a * b = a * c → b = c
nat_mul_left_cancel p: ℕ
p _: ℕ
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.59167} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt (Nat.lt_trans: ∀ {n m k : ℕ}, n < m → m < k → n < k
Nat.lt_trans (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.59180
0) prime: nat_prime p
prime.1: ∀ {a b : Prop}, a ∧ b → a
1))R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) / p * (d + 1))
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

(c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) / p * (d + 1))Nat.mul_div_cancel': ∀ {n m : ℕ}, n ∣ m → n * (m / n) = m
Nat.mul_div_cancel' (Nat.dvd_of_mod_eq_zero: ∀ {m n : ℕ}, n % m = 0 → m ∣ n
Nat.dvd_of_mod_eq_zero h: (c + 1) * (d + 1) % p = 0
h),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

(c + 1) * (d + 1) = p * ((c + 1) / p * (d + 1)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) / p * (d + 1))←mul_assoc: ∀ {G : Type ?u.59199} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

(c + 1) * (d + 1) = p * ((c + 1) / p) * (d + 1) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) / p * (d + 1))Nat.mul_div_cancel': ∀ {n m : ℕ}, n ∣ m → n * (m / n) = m
Nat.mul_div_cancel' (Nat.dvd_of_mod_eq_zero: ∀ {m n : ℕ}, n % m = 0 → m ∣ n
Nat.dvd_of_mod_eq_zero h': (c + 1) % p = 0
h')R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

(c + 1) * (d + 1) = (c + 1) * (d + 1)]
Goals accomplished! 🐙
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)

inl.inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) / p * (d + 1)))mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)
mul_div_assocR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (c + 1) % p = 0

sum_le_n: (c + 1) / p + (d + 1) ≤ n

mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) / p * (d + 1)

inl.inlsucc (nat_valuation p ((c + 1) / p * (d + 1))) = succ (nat_valuation p ((c + 1) / p * (d + 1)))]
Goals accomplished! 🐙
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

x✝: (c + 1) % p = 0 ∨ (d + 1) % p = 0

inlsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))| inr: ∀ {a b : Prop}, b → a ∨ b
inr h': ?m.58469
h' =>
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_neg: ∀ {c : Prop} {h : Decidable c}, ¬c → ∀ {α : Sort ?u.59351} {t e : α}, (if c then t else e) = e
if_neg (not_not_intro: ∀ {p : Prop}, p → ¬¬p
not_not_intro h': ?m.58469
h'),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) + succ (nat_valuation p ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))←hq: q + 2 = p
hq,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation (q + 2) ((c + 1) * (d + 1) / (q + 2))) =   (if (c + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((c + 1) / (q + 2)))) +     succ (nat_valuation (q + 2) ((d + 1) / (q + 2))) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))←nat_val_succ: ∀ (q m : ℕ),
  nat_valuation (q + 2) (m + 1) =     if (m + 1) % (q + 2) ≠ 0 then ofN 0 else succ (nat_valuation (q + 2) ((m + 1) / (q + 2)))
nat_val_succ q: ℕ
q c: ℕ
c,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation (q + 2) ((c + 1) * (d + 1) / (q + 2))) =   nat_valuation (q + 2) (c + 1) + succ (nat_valuation (q + 2) ((d + 1) / (q + 2))) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))hq: q + 2 = p
hq,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = nat_valuation p (c + 1) + succ (nat_valuation p ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))add_succ: ∀ (a b : ℕ∪∞), a + succ b = succ (a + b)
add_succR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p (c + 1) + nat_valuation p ((d + 1) / p))]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p (c + 1) + nat_valuation p ((d + 1) / p))
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have sum_le_n: c + 1 + (d + 1) / p ≤ n
sum_le_n : (c: ℕ
c + 1: ?m.59396
1) + (d: ℕ
d + 1: ?m.59413
1) / p: ℕ
p ≤ n: ℕ
n := R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p (c + 1) + nat_valuation p ((d + 1) / p))by
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ napply Nat.le_of_lt_succ: ∀ {m n : ℕ}, m < Nat.succ n → m ≤ n
Nat.le_of_lt_succR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

ac + 1 + (d + 1) / p < Nat.succ n
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ napply lt_of_lt_of_le: ∀ {α : Type ?u.59537} [inst : Preorder α] {a b c : α}, a < b → b ≤ c → a < c
lt_of_lt_of_le _: ?m.59540 < ?m.59541
_ h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n
h_sumR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p < Nat.succ c + Nat.succ d
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ napply Nat.add_lt_add_left: ∀ {n m : ℕ}, n < m → ∀ (k : ℕ), k + n < k + m
Nat.add_lt_add_leftR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

h(d + 1) / p < Nat.succ d
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ napply Nat.div_lt_self: ∀ {n k : ℕ}, 0 < n → 1 < k → n / k < n
Nat.div_lt_self _: 0 < ?m.59556
_ prime: nat_prime p
prime.1: ∀ {a b : Prop}, a ∧ b → a
1R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

0 < d + 1
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ nrw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

0 < d + 1Nat.add_comm: ∀ (n m : ℕ), n + m = m + n
Nat.add_commR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

0 < 1 + d]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

0 < 1 + d
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

c + 1 + (d + 1) / p ≤ napply Nat.lt_add_right: ∀ (a b c : ℕ), a < b → a < b + c
Nat.lt_add_right 0: ?m.59573
0 1: ?m.59576
1 d: ℕ
d (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.59579
0)
Goals accomplished! 🐙
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p (c + 1) + nat_valuation p ((d + 1) / p))←ih: ?m.56102 n
ih (c: ℕ
c + 1: ?m.59586
1) ((d: ℕ
d + 1: ?m.59629
1) / p: ℕ
p) sum_le_n: c + 1 + (d + 1) / p ≤ n
sum_le_nR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) * ((d + 1) / p)))]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) * ((d + 1) / p)))
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)
mul_div_assoc : (c: ℕ
c + 1: ?m.59708
1) * (d: ℕ
d + 1: ?m.59722
1) / p: ℕ
p = (c: ℕ
c + 1: ?m.59749
1) * ((d: ℕ
d + 1: ?m.59766
1) / p: ℕ
p) := R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) * ((d + 1) / p)))by
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)apply nat_mul_left_cancel: ∀ (a b c : ℕ), a ≠ 0 → a * b = a * c → b = c
nat_mul_left_cancel p: ℕ
p _: ℕ
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.59971} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt (Nat.lt_trans: ∀ {n m k : ℕ}, n < m → m < k → n < k
Nat.lt_trans (Nat.lt_succ_self: ∀ (n : ℕ), n < Nat.succ n
Nat.lt_succ_self 0: ?m.59981
0) prime: nat_prime p
prime.1: ∀ {a b : Prop}, a ∧ b → a
1))R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))
                  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))Nat.mul_div_cancel': ∀ {n m : ℕ}, n ∣ m → n * (m / n) = m
Nat.mul_div_cancel' (Nat.dvd_of_mod_eq_zero: ∀ {m n : ℕ}, n % m = 0 → m ∣ n
Nat.dvd_of_mod_eq_zero h: (c + 1) * (d + 1) % p = 0
h),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) = p * ((c + 1) * ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))←mul_assoc: ∀ {G : Type ?u.59996} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) = p * (c + 1) * ((d + 1) / p) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))mul_comm: ∀ {G : Type ?u.60070} [inst : CommSemigroup G] (a b : G), a * b = b * a
mul_comm p: ℕ
p,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) = (c + 1) * p * ((d + 1) / p) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))mul_assoc: ∀ {G : Type ?u.60098} [inst : Semigroup G] (a b c : G), a * b * c = a * (b * c)
mul_assoc,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) = (c + 1) * (p * ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

p * ((c + 1) * (d + 1) / p) = p * ((c + 1) * ((d + 1) / p))Nat.mul_div_cancel': ∀ {n m : ℕ}, n ∣ m → n * (m / n) = m
Nat.mul_div_cancel' (Nat.dvd_of_mod_eq_zero: ∀ {m n : ℕ}, n % m = 0 → m ∣ n
Nat.dvd_of_mod_eq_zero h': (d + 1) % p = 0
h')R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

(c + 1) * (d + 1) = (c + 1) * (d + 1)]
Goals accomplished! 🐙
                R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)

inl.inrsucc (nat_valuation p ((c + 1) * (d + 1) / p)) = succ (nat_valuation p ((c + 1) * ((d + 1) / p)))mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)
mul_div_assocR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p = 0

h': (d + 1) % p = 0

sum_le_n: c + 1 + (d + 1) / p ≤ n

mul_div_assoc: (c + 1) * (d + 1) / p = (c + 1) * ((d + 1) / p)

inl.inrsucc (nat_valuation p ((c + 1) * ((d + 1) / p))) = succ (nat_valuation p ((c + 1) * ((d + 1) / p)))]
Goals accomplished! 🐙
            R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

x✝: (c + 1) * (d + 1) % p = 0 ∨ (c + 1) * (d + 1) % p > 0

(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))| inr: ∀ {a b : Prop}, b → a ∨ b
inr h: ?m.58274
h =>
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have hc: ?m.60210
hc := ndiv_mul_left: ∀ (a b p : ℕ), a * b % p ≠ 0 → a % p ≠ 0
ndiv_mul_left _: ℕ
_ _: ℕ
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.60215} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h: ?m.58274
h)R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))have hd: ?m.60228
hd := ndiv_mul_right: ∀ (a b p : ℕ), a * b % p ≠ 0 → b % p ≠ 0
ndiv_mul_right _: ℕ
_ _: ℕ
_ _: ℕ
_ (ne_of_gt: ∀ {α : Type ?u.60233} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h: ?m.58274
h)R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))rw [R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_pos: ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort ?u.60245} {t e : α}, (if c then t else e) = t
if_pos (ne_of_gt: ∀ {α : Type ?u.60248} [inst : Preorder α] {a b : α}, b < a → a ≠ b
ne_of_gt h: ?m.58274
h),R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inrofN 0 =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_pos: ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort ?u.60273} {t e : α}, (if c then t else e) = t
if_pos hc: ?m.60210
hc,R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inrofN 0 = ofN 0 + if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p)) R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))if_pos: ∀ {c : Prop} {h : Decidable c}, c → ∀ {α : Sort ?u.60287} {t e : α}, (if c then t else e) = t
if_pos hd: ?m.60228
hdR: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inrofN 0 = ofN 0 + ofN 0]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

hc: (c + 1) % p ≠ 0

hd: (d + 1) % p ≠ 0

inrofN 0 = ofN 0 + ofN 0
              R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b, n: ℕ

ih: ∀ (c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d

c, d: ℕ

h_sum: Nat.succ c + Nat.succ d ≤ Nat.succ n

q: ℕ

hq: q + 2 = p

h: (c + 1) * (d + 1) % p > 0

inr(if (c + 1) * (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) * (d + 1) / p))) =   (if (c + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((c + 1) / p))) +     if (d + 1) % p ≠ 0 then ofN 0 else succ (nat_valuation p ((d + 1) / p))simp
Goals accomplished! 🐙
  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℕ

nat_valuation p (a * b) = nat_valuation p a + nat_valuation p bapply general: ∀ (n c d : ℕ), c + d ≤ n → nat_valuation p (c * d) = nat_valuation p c + nat_valuation p d
general (a: ℕ
a + b: ℕ
b) a: ℕ
a b: ℕ
b (le_refl: ∀ {α : Type ?u.60361} [inst : Preorder α] (a : α), a ≤ a
le_refl _: ?m.60362
_)
Goals accomplished! 🐙

lemma int_val_mul_eq_add: ∀ (p : ℕ), nat_prime p → ∀ (a b : ℤ), int_val p (a * b) = int_val p a + int_val p b
int_val_mul_eq_add (p: ℕ
p : ℕ: Type
ℕ) (prime: nat_prime p
prime : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) (a: ℤ
a b: ℤ
b : ℤ: Type
ℤ) : int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p (a: ℤ
a * b: ℤ
b) = int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p a: ℤ
a + int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p b: ℤ
b := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℤ

int_val p (a * b) = int_val p a + int_val p bsimp [int_val: ℕ → ℤ → ℕ∪∞
int_val, natAbs_mul: ∀ (a b : ℤ), natAbs (a * b) = natAbs a * natAbs b
natAbs_mul]R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℤ

nat_valuation p (natAbs a * natAbs b) = nat_valuation p (natAbs a) + nat_valuation p (natAbs b)
  R: Type u

inst✝: IntegralDomain R

p: ℕ

prime: nat_prime p

a, b: ℤ

int_val p (a * b) = int_val p a + int_val p bexact nat_val_mul_eq_add: ∀ (p : ℕ), nat_prime p → ∀ (a b : ℕ), nat_valuation p (a * b) = nat_valuation p a + nat_valuation p b
nat_val_mul_eq_add p: ℕ
p prime: nat_prime p
prime (natAbs: ℤ → ℕ
natAbs a: ℤ
a) (natAbs: ℤ → ℕ
natAbs b: ℤ
b)
Goals accomplished! 🐙


lemma nat_val_add_ge_min: ∀ (p a b : ℕ), nat_valuation p (a + b) ≥ min (nat_valuation p a) (nat_valuation p b)
nat_val_add_ge_minWarning: declaration uses 'sorry' (p: ℕ
p a: ℕ
a b: ℕ
b : ℕ: Type
ℕ) : nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p (a: ℕ
a + b: ℕ
b) ≥ min: {α : Type ?u.60773} → [self : Min α] → α → α → α
min (nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p a: ℕ
a) (nat_valuation: ℕ → ℕ → ℕ∪∞
nat_valuation p: ℕ
p b: ℕ
b) := by R: Type u

inst✝: IntegralDomain R

p, a, b: ℕ

nat_valuation p (a + b) ≥ min (nat_valuation p a) (nat_valuation p b)sorry
Goals accomplished! 🐙

lemma natAbs_add: ∀ (a b : ℤ), natAbs (a + b) = max (natAbs a) (natAbs b) - min (natAbs a) (natAbs b)
natAbs_addWarning: declaration uses 'sorry' (a: ℤ
a b: ℤ
b : ℤ: Type
ℤ) : natAbs: ℤ → ℕ
natAbs (a: ℤ
a + b: ℤ
b) = max: {α : Type ?u.60858} → [self : Max α] → α → α → α
max (natAbs: ℤ → ℕ
natAbs a: ℤ
a) (natAbs: ℤ → ℕ
natAbs b: ℤ
b) - min: {α : Type ?u.60864} → [self : Min α] → α → α → α
min (natAbs: ℤ → ℕ
natAbs a: ℤ
a) (natAbs: ℤ → ℕ
natAbs b: ℤ
b) := by R: Type u

inst✝: IntegralDomain R

a, b: ℤ

natAbs (a + b) = max (natAbs a) (natAbs b) - min (natAbs a) (natAbs b)sorry
Goals accomplished! 🐙

lemma int_val_add_ge_min: ∀ (p : ℕ) (a b : ℤ), int_val p (a + b) ≥ min (int_val p a) (int_val p b)
int_val_add_ge_minWarning: declaration uses 'sorry' (p: ℕ
p : ℕ: Type
ℕ) (a: ℤ
a b: ℤ
b : ℤ: Type
ℤ) : int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p (a: ℤ
a + b: ℤ
b) ≥ min: {α : Type ?u.60970} → [self : Min α] → α → α → α
min (int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p a: ℤ
a) (int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p b: ℤ
b) := by
  R: Type u

inst✝: IntegralDomain R

p: ℕ

a, b: ℤ

int_val p (a + b) ≥ min (int_val p a) (int_val p b)simp [int_val: ℕ → ℤ → ℕ∪∞
int_val, natAbs_add: ∀ (a b : ℤ), natAbs (a + b) = max (natAbs a) (natAbs b) - min (natAbs a) (natAbs b)
natAbs_add]R: Type u

inst✝: IntegralDomain R

p: ℕ

a, b: ℤ

nat_valuation p (max (natAbs a) (natAbs b) - min (natAbs a) (natAbs b)) ≥   min (nat_valuation p (natAbs a)) (nat_valuation p (natAbs b))
  -- exact nat_val_add_ge_min p (natAbs a) (natAbs b)
  R: Type u

inst✝: IntegralDomain R

p: ℕ

a, b: ℤ

int_val p (a + b) ≥ min (int_val p a) (int_val p b)sorry
Goals accomplished! 🐙

lemma int_val_add_eq_min: ∀ (p : ℕ) (a b : ℤ), int_val p a < int_val p b → int_val p (a + b) = int_val p a
int_val_add_eq_minWarning: declaration uses 'sorry' (p: ℕ
p : ℕ: Type
ℕ) (a: ℤ
a b: ℤ
b : ℤ: Type
ℤ) (h: int_val p a < int_val p b
h : int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p a: ℤ
a < int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p b: ℤ
b) :
  int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p (a: ℤ
a + b: ℤ
b) = int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p a: ℤ
a := by R: Type u

inst✝: IntegralDomain R

p: ℕ

a, b: ℤ

h: int_val p a < int_val p b

int_val p (a + b) = int_val p asorry
Goals accomplished! 🐙

lemma int_val_eq_top_iff_zero: ∀ (p : ℕ), 1 < p → ∀ (a : ℤ), int_val p a = ∞ ↔ a = 0
int_val_eq_top_iff_zeroWarning: declaration uses 'sorry' (p: ℕ
p : ℕ: Type
ℕ) (gt1: 1 < p
gt1 : 1: ?m.61312
1 < p: ℕ
p) (a: ℤ
a : ℤ: Type
ℤ) : int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p a: ℤ
a = ∞: ℕ∪∞
∞ ↔ a: ℤ
a = 0: ?m.61353
0 := by R: Type u

inst✝: IntegralDomain R

p: ℕ

gt1: 1 < p

a: ℤ

int_val p a = ∞ ↔ a = 0sorry
Goals accomplished! 🐙

def primeVal: {p : ℕ} → nat_prime p → SurjVal ↑p
primeVal {p: ℕ
p : ℕ: Type
ℕ} (hp: nat_prime p
hp : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) : SurjVal: {R : Type ?u.61394} → R → [inst : IntegralDomain R] → Type ?u.61394
SurjVal (ofNat: ℕ → ℤ
ofNat p: ℕ
p) := {
  v := int_val: ℕ → ℤ → ℕ∪∞
int_val p: ℕ
p,
  v_uniformizer := int_val_uniformizer: ∀ {p : ℕ}, 1 < p → int_val p ↑p = ofN 1
int_val_uniformizer hp: nat_prime p
hp.left: ∀ {a b : Prop}, a ∧ b → a
left,
  v_mul_eq_add_v := int_val_mul_eq_add: ∀ (p : ℕ), nat_prime p → ∀ (a b : ℤ), int_val p (a * b) = int_val p a + int_val p b
int_val_mul_eq_add p: ℕ
p hp: nat_prime p
hp,
  v_add_ge_min_v := int_val_add_ge_min: ∀ (p : ℕ) (a b : ℤ), int_val p (a + b) ≥ min (int_val p a) (int_val p b)
int_val_add_ge_min p: ℕ
p,
  v_eq_top_iff_zero := int_val_eq_top_iff_zero: ∀ (p : ℕ), 1 < p → ∀ (a : ℤ), int_val p a = ∞ ↔ a = 0
int_val_eq_top_iff_zero p: ℕ
p hp: nat_prime p
hp.left: ∀ {a b : Prop}, a ∧ b → a
left
  }

def decr_val_p: ℕ → (ℤ → ℕ∪∞) → ℤ → ℤ
decr_val_p (p: ℕ
p : ℕ: Type
ℕ) (val: ℤ → ℕ∪∞
val : ℤ: Type
ℤ → ℕ∪∞: Type
ℕ∪∞) (k: ℤ
k : ℤ: Type
ℤ) : ℤ: Type
ℤ :=
  match val: ℤ → ℕ∪∞
val k: ℤ
k with
  | 0: ℕ∪∞
0 => k: ℤ
k
  | _ => k: ℤ
k / p: ℕ
p

lemma zero_valtn_decr_p: ∀ {p : ℕ} {k : ℤ} (val : ℤ → ℕ∪∞), val k = 0 → decr_val_p p val k = k
zero_valtn_decr_p {p: ℕ
p: ℕ: Type
ℕ} {k: ℤ
k : ℤ: Type
ℤ} (val: ℤ → ℕ∪∞
val : ℤ: Type
ℤ → ℕ∪∞: Type
ℕ∪∞) (h: val k = 0
h : val: ℤ → ℕ∪∞
val k: ℤ
k = 0: ?m.62195
0) : decr_val_p: ℕ → (ℤ → ℕ∪∞) → ℤ → ℤ
decr_val_p p: ℕ
p val: ℤ → ℕ∪∞
val k: ℤ
k = k: ℤ
k :=
by R: Type u

inst✝: IntegralDomain R

p: ℕ

k: ℤ

val: ℤ → ℕ∪∞

h: val k = 0

decr_val_p p val k = krw [R: Type u

inst✝: IntegralDomain R

p: ℕ

k: ℤ

val: ℤ → ℕ∪∞

h: val k = 0

decr_val_p p val k = kdecr_val_p: ℕ → (ℤ → ℕ∪∞) → ℤ → ℤ
decr_val_p,R: Type u

inst✝: IntegralDomain R

p: ℕ

k: ℤ

val: ℤ → ℕ∪∞

h: val k = 0

(match val k with
  | ofN Nat.zero => k
  | x => k / ↑p) =   k R: Type u

inst✝: IntegralDomain R

p: ℕ

k: ℤ

val: ℤ → ℕ∪∞

h: val k = 0

decr_val_p p val k = kh: val k = 0
hR: Type u

inst✝: IntegralDomain R

p: ℕ

k: ℤ

val: ℤ → ℕ∪∞

h: val k = 0

(match 0 with
  | ofN Nat.zero => k
  | x => k / ↑p) =   k]
Goals accomplished! 🐙

def norm_repr_p: ℕ → ℤ → ℤ
norm_repr_p (p: ℕ
p : ℕ: Type
ℕ) (x: ℤ
x : ℤ: Type
ℤ) : ℤ: Type
ℤ := (x: ℤ
x % (p: ℕ
p : ℤ: Type
ℤ) + p: ℕ
p) % (p: ℕ
p : ℤ: Type
ℤ)

lemma def_char_p: ∀ {p : ℕ} {hp : nat_prime p} (p_1 n : ℕ), SurjVal.v (primeVal hp) ↑n > 0 ↔ p_1 ∣ n
def_char_pWarning: declaration uses 'sorry' (p: ℕ
p : ℕ: Type
ℕ) : ∀ n: ℕ
n : ℕ: Type
ℕ, (primeVal: {p : ℕ} → nat_prime p → SurjVal ↑p
primeVal hp: ?m.62796
hp).v: {R : Type ?u.62808} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v n: ℕ
n > 0: ?m.62904
0 ↔ p: ℕ
p ∣ n: ℕ
n := sorry: ?m.63136
sorry

def primeEVR: {p : ℕ} → nat_prime p → EnatValRing ↑p
primeEVRWarning: declaration uses 'sorry' {p: ℕ
p : ℕ: Type
ℕ} (hp: nat_prime p
hp : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) : EnatValRing: {R : Type ?u.63153} → R → [inst : IntegralDomain R] → Type ?u.63153
EnatValRing (p: ℕ
p : ℤ: Type
ℤ) := {
  valtn := primeVal: {p : ℕ} → nat_prime p → SurjVal ↑p
primeVal hp: nat_prime p
hp,
  decr_val := decr_val_p: ℕ → (ℤ → ℕ∪∞) → ℤ → ℤ
decr_val_p p: ℕ
p (primeVal: {p : ℕ} → nat_prime p → SurjVal ↑p
primeVal hp: nat_prime p
hp).v: {R : Type ?u.63264} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v,
  zero_valtn_decr := zero_valtn_decr_p: ∀ {p : ℕ} {k : ℤ} (val : ℤ → ℕ∪∞), val k = 0 → decr_val_p p val k = k
zero_valtn_decr_p (primeVal: {p : ℕ} → nat_prime p → SurjVal ↑p
primeVal hp: nat_prime p
hp).v: {R : Type ?u.63278} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v,
  pos_valtn_decr := sorry: ?m.63305
sorry,
  residue_char := p: ℕ
p,
  def_char := def_char_p: ∀ {p : ℕ} {hp : nat_prime p} (p_1 n : ℕ), SurjVal.v (primeVal hp) ↑n > 0 ↔ p_1 ∣ n
def_char_p p: ℕ
p,
  norm_repr := norm_repr_p: ℕ → ℤ → ℤ
norm_repr_p p: ℕ
p,
  quad_roots_in_residue_field := fun a: ?m.64430
a b: ?m.64433
b c: ?m.64436
c => Int.quad_root_in_ZpZ: ℤ → ℤ → ℤ → ℕ → Bool
Int.quad_root_in_ZpZ a: ?m.64430
a b: ?m.64433
b c: ?m.64436
c p: ℕ
p
}

lemma prime_2: nat_prime 2
prime_2Warning: declaration uses 'sorry' : nat_prime: ℕ → Prop
nat_prime 2: ?m.64685
2 := by
  R: Type u

inst✝: IntegralDomain R

nat_prime 2simp only [nat_prime: ℕ → Prop
nat_prime, true_and: ∀ (p : Prop), (True ∧ p) = p
true_and]R: Type u

inst✝: IntegralDomain R

∀ (a b : ℕ), a * b % 2 = 0 → a % 2 = 0 ∨ b % 2 = 0
  R: Type u

inst✝: IntegralDomain R

nat_prime 2sorry
Goals accomplished! 🐙
lemma prime_3: nat_prime 3
prime_3Warning: declaration uses 'sorry' : nat_prime: ℕ → Prop
nat_prime 3: ?m.64895
3 := by
  R: Type u

inst✝: IntegralDomain R

nat_prime 3simp only [nat_prime: ℕ → Prop
nat_prime, true_and: ∀ (p : Prop), (True ∧ p) = p
true_and]R: Type u

inst✝: IntegralDomain R

∀ (a b : ℕ), a * b % 3 = 0 → a % 3 = 0 ∨ b % 3 = 0
  R: Type u

inst✝: IntegralDomain R

nat_prime 3sorry
Goals accomplished! 🐙

def modulo: (x : ℤ) → (p : ℕ) → ?m.65109 x p
modulo (x: ℤ
x : ℤ: Type
ℤ) (p: ℕ
p : ℕ: Type
ℕ) := (x: ℤ
x % (p: ℕ
p:ℤ: Type
ℤ) + p: ℕ
p) % (p: ℕ
p:ℤ: Type
ℤ)

def inv_mod: (x : ℤ) → (p : ℕ) → ?m.65412 x p
inv_mod (x: ℤ
x : ℤ: Type
ℤ) (p: ℕ
p : ℕ: Type
ℕ) := modulo: ℤ → ℕ → ℤ
modulo (x: ℤ
x ^ (p: ℕ
p - 2: ?m.65427
2)) p: ℕ
p

def has_double_root: (a b c : ℤ) → {p : ℕ} → (hp : nat_prime p) → ?m.65697 a b c hp
has_double_root (a: ℤ
a b: ℤ
b c: ℤ
c : ℤ: Type
ℤ) {p: ℕ
p : ℕ: Type
ℕ} (hp: nat_prime p
hp : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) :=
  let v_p: ?m.65705
v_p := (primeEVR: {p : ℕ} → nat_prime p → EnatValRing ↑p
primeEVR hp: nat_prime p
hp).valtn: {R : Type ?u.65708} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.65718} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v;
  v_p: ?m.65705
v_p a: ℤ
a = 0: ?m.65741
0 ∧ v_p: ?m.65705
v_p (b: ℤ
b ^ 2: ?m.65977
2 - 4: ?m.65993
4 * a: ℤ
a * c: ℤ
c) > 0: ?m.66214
0

def double_root: (a b c : ℤ) → (p : ℕ) → ?m.66484 a b c p
double_root (a: ℤ
a b: ℤ
b c: ℤ
c : ℤ: Type
ℤ) (p: ℕ
p : ℕ: Type
ℕ) :=
  if p: ℕ
p = 2: ?m.66492
2 then
    modulo: ℤ → ℕ → ℤ
modulo c: ℤ
c 2: ?m.66526
2
  else
    modulo: ℤ → ℕ → ℤ
modulo (-b: ℤ
b * inv_mod: ℤ → ℕ → ℤ
inv_mod (2: ?m.66536
2 * a: ℤ
a) p: ℕ
p) p: ℕ
p

lemma val_poly_of_double_root: ∀ {p : ℕ} (hp : nat_prime p) (a b c : ℤ),
  has_double_root a b c hp →
    let x := double_root a b c p;
    let v_p := (primeEVR hp).valtn.v;
    v_p (a * x ^ 2 + b * x + c) > 0 ∧ v_p (2 * a * x + b) > 0
val_poly_of_double_rootWarning: declaration uses 'sorry' {p: ℕ
p : ℕ: Type
ℕ} (hp: nat_prime p
hp : nat_prime: ℕ → Prop
nat_prime p: ℕ
p) (a: ℤ
a b: ℤ
b c: ℤ
c : ℤ: Type
ℤ) (H: has_double_root a b c hp
H : has_double_root: ℤ → ℤ → ℤ → {p : ℕ} → nat_prime p → Prop
has_double_root a: ℤ
a b: ℤ
b c: ℤ
c hp: nat_prime p
hp) : let x: ?m.66755
x := double_root: ℤ → ℤ → ℤ → ℕ → ℤ
double_root a: ℤ
a b: ℤ
b c: ℤ
c p: ℕ
p; let v_p: ?m.66758
v_p := (primeEVR: {p : ℕ} → nat_prime p → EnatValRing ↑p
primeEVR hp: nat_prime p
hp).valtn: {R : Type ?u.66760} → {p : R} → [inst : IntegralDomain R] → EnatValRing p → SurjVal p
valtn.v: {R : Type ?u.66770} → {p : R} → [inst : IntegralDomain R] → SurjVal p → R → ℕ∪∞
v; v_p: ?m.66758
v_p (a: ℤ
a*x: ?m.66755
x^2: ?m.66795
2 + b: ℤ
b*x: ?m.66755
x + c: ℤ
c) > 0: ?m.67022
0 ∧ v_p: ?m.66758
v_p (2: ?m.67334
2*a: ℤ
a*x: ?m.66755
x + b: ℤ
b) > 0: ?m.67418
0 := by R: Type u

inst✝: IntegralDomain R

p: ℕ

hp: nat_prime p

a, b, c: ℤ

H: has_double_root a b c hp

let x := double_root a b c p;
let v_p := (primeEVR hp).valtn.v;
v_p (a * x ^ 2 + b * x + c) > 0 ∧ v_p (2 * a * x + b) > 0sorry
Goals accomplished! 🐙



end Int